TDMParser.java

  1. /* Copyright 2002-2020 CS Group
  2.  * Licensed to CS Group (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 javax.xml.parsers.ParserConfigurationException;
  20. import javax.xml.parsers.SAXParser;
  21. import javax.xml.parsers.SAXParserFactory;
  22. import java.io.BufferedReader;
  23. import java.io.FileInputStream;
  24. import java.io.IOException;
  25. import java.io.InputStream;
  26. import java.io.InputStreamReader;
  27. import java.nio.charset.StandardCharsets;
  28. import java.util.ArrayList;
  29. import java.util.List;
  30. import java.util.Locale;

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


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

  74.     /** Enumerate for the format. */
  75.     public enum TDMFileFormat {

  77.         /** Keyvalue (text file with Key = Value lines). */
  78.         KEYVALUE,

  80.         /** XML format. */
  81.         XML,

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

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

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

  93.     /** IERS Conventions. */
  94.     private final  IERSConventions conventions;

  96.     /** Indicator for simple or accurate EOP interpolation. */
  97.     private final  boolean simpleEOP;

  99.     /** Data context for frames, time scales, etc. */
  100.     private final DataContext dataContext;

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

  140.     /** Complete constructor.
  141.      * @param fileFormat The format of the file: KEYVALUE or XML
  142.      * @param missionReferenceDate reference date for Mission Elapsed Time or Mission Relative Time time systems
  143.      * @param conventions IERS Conventions
  144.      * @param simpleEOP if true, tidal effects are ignored when interpolating EOP
  145.      * @param dataContext used to retrieve frames, time scales, etc.
  146.      */
  147.     private TDMParser(final TDMFileFormat fileFormat,
  148.                       final AbsoluteDate missionReferenceDate,
  149.                       final IERSConventions conventions,
  150.                       final boolean simpleEOP,
  151.                       final DataContext dataContext) {
  152.         this.fileFormat = fileFormat;
  153.         this.missionReferenceDate = missionReferenceDate;
  154.         this.conventions          = conventions;
  155.         this.simpleEOP            = simpleEOP;
  156.         this.dataContext = dataContext;
  157.     }

  159.     /** Set file format.
  160.      * @param newFileFormat The format of the file: KEYVALUE or XML
  161.      * @return a new instance, with file format set to newFileFormat
  162.      * @see #getFileFormat()
  163.      */
  164.     public TDMParser withFileFormat(final TDMFileFormat newFileFormat) {
  165.         return new TDMParser(newFileFormat, getMissionReferenceDate(), getConventions(),
  166.                 isSimpleEOP(), getDataContext());
  167.     }

  169.     /** Get file format.
  170.      * @return the file format
  171.      * @see #withFileFormat(TDMFileFormat)
  172.      */
  173.     public TDMFileFormat getFileFormat() {
  174.         return fileFormat;
  175.     }

  177.     /** Set initial date.
  178.      * @param newMissionReferenceDate mission reference date to use while parsing
  179.      * @return a new instance, with mission reference date replaced
  180.      * @see #getMissionReferenceDate()
  181.      */
  182.     public TDMParser withMissionReferenceDate(final AbsoluteDate newMissionReferenceDate) {
  183.         return new TDMParser(getFileFormat(), newMissionReferenceDate, getConventions(),
  184.                 isSimpleEOP(), getDataContext());
  185.     }

  187.     /** Get initial date.
  188.      * @return mission reference date to use while parsing
  189.      * @see #withMissionReferenceDate(AbsoluteDate)
  190.      */
  191.     public AbsoluteDate getMissionReferenceDate() {
  192.         return missionReferenceDate;
  193.     }

  195.     /** Set IERS conventions.
  196.      * @param newConventions IERS conventions to use while parsing
  197.      * @return a new instance, with IERS conventions replaced
  198.      * @see #getConventions()
  199.      */
  200.     public TDMParser withConventions(final IERSConventions newConventions) {
  201.         return new TDMParser(getFileFormat(), getMissionReferenceDate(), newConventions,
  202.                 isSimpleEOP(), getDataContext());
  203.     }

  205.     /** Get IERS conventions.
  206.      * @return IERS conventions to use while parsing
  207.      * @see #withConventions(IERSConventions)
  208.      */
  209.     public IERSConventions getConventions() {
  210.         return conventions;
  211.     }

  213.     /** Set EOP interpolation method.
  214.      * @param newSimpleEOP if true, tidal effects are ignored when interpolating EOP
  215.      * @return a new instance, with EOP interpolation method replaced
  216.      * @see #isSimpleEOP()
  217.      */
  218.     public TDMParser withSimpleEOP(final boolean newSimpleEOP) {
  219.         return new TDMParser(getFileFormat(), getMissionReferenceDate(), getConventions(),
  220.                 newSimpleEOP, getDataContext());
  221.     }

  223.     /** Get EOP interpolation method.
  224.      * @return true if tidal effects are ignored when interpolating EOP
  225.      * @see #withSimpleEOP(boolean)
  226.      */
  227.     public boolean isSimpleEOP() {
  228.         return simpleEOP;
  229.     }

  231.     /**
  232.      * Get the data context.
  233.      *
  234.      * @return the data context used for retrieving frames, time scales, etc.
  235.      */
  236.     public DataContext getDataContext() {
  237.         return dataContext;
  238.     }

  240.     /**
  241.      * Set the data context.
  242.      *
  243.      * @param newDataContext used for retrieving frames, time scales, etc.
  244.      * @return a new instance with the data context replaced.
  245.      */
  246.     public TDMParser withDataContext(final DataContext newDataContext) {
  247.         return new TDMParser(getFileFormat(), getMissionReferenceDate(), getConventions(),
  248.                 isSimpleEOP(), newDataContext);
  249.     }

  251.     /** Parse a CCSDS Tracking Data Message.
  252.      * @param fileName name of the file containing the message
  253.      * @return parsed file content in a TDMFile object
  254.      */
  255.     public TDMFile parse(final String fileName) {
  256.         try (InputStream stream = new FileInputStream(fileName)) {
  257.             return parse(stream, fileName);
  258.         } catch (IOException ioe) {
  259.             throw new OrekitException(OrekitMessages.UNABLE_TO_FIND_FILE, fileName);
  260.         }
  261.     }

  263.     /** Parse a CCSDS Tracking Data Message.
  264.      * @param stream stream containing message
  265.      * @return parsed file content in a TDMFile object
  266.      */
  267.     public TDMFile parse(final InputStream stream) {
  268.         return parse(stream, "<unknown>");
  269.     }

  271.     /** Parse a CCSDS Tracking Data Message.
  272.      * @param stream stream containing message
  273.      * @param fileName name of the file containing the message (for error messages)
  274.      * @return parsed file content in a TDMFile object
  275.      */
  276.     public TDMFile parse(final InputStream stream, final String fileName) {

  278.         // Set the format of the file automatically
  279.         // If it is obvious and was not formerly specified
  280.         // Then, use a different parsing method for each file format
  281.         if (TDMFileFormat.UNKNOWN.equals(fileFormat)) {
  282.             if (fileName.toLowerCase(Locale.US).endsWith(".txt")) {
  283.                 // Keyvalue format case
  284.                 return this.withFileFormat(TDMFileFormat.KEYVALUE).parse(stream, fileName);
  285.             } else if (fileName.toLowerCase(Locale.US).endsWith(".xml")) {
  286.                 // XML format case
  287.                 return this.withFileFormat(TDMFileFormat.XML).parse(stream, fileName);
  288.             } else {
  289.                 throw new OrekitException(OrekitMessages.CCSDS_TDM_UNKNOWN_FORMAT, fileName);
  290.             }
  291.         } else if (this.fileFormat.equals(TDMFileFormat.KEYVALUE)) {
  292.             return parseKeyValue(stream, fileName);
  293.         } else if (this.fileFormat.equals(TDMFileFormat.XML)) {
  294.             return parseXml(stream, fileName);
  295.         } else {
  296.             throw new OrekitException(OrekitMessages.CCSDS_TDM_UNKNOWN_FORMAT, fileName);
  297.         }
  298.     }

  300.     /** Parse a CCSDS Tracking Data Message with KEYVALUE format.
  301.      * @param stream stream containing message
  302.      * @param fileName name of the file containing the message (for error messages)
  303.      * @return parsed file content in a TDMFile object
  304.      */
  305.     public TDMFile parseKeyValue(final InputStream stream, final String fileName) {

  307.         final KeyValueHandler handler = new KeyValueHandler(new ParseInfo(this.getMissionReferenceDate(),
  308.                                                                     this.getConventions(),
  309.                                                                     this.isSimpleEOP(),
  310.                                                                     fileName,
  311.                                                                     getDataContext()));
  312.         return handler.parse(stream, fileName);
  313.     }



  317.     /** Parse a CCSDS Tracking Data Message with XML format.
  318.      * @param stream stream containing message
  319.      * @param fileName name of the file containing the message (for error messages)
  320.      * @return parsed file content in a TDMFile object
  321.      */
  322.     public TDMFile parseXml(final InputStream stream, final String fileName) {
  323.         try {
  324.             // Create the handler
  325.             final XMLHandler handler = new XMLHandler(new ParseInfo(this.getMissionReferenceDate(),
  326.                                                                     this.getConventions(),
  327.                                                                     this.isSimpleEOP(),
  328.                                                                     fileName,
  329.                                                                     getDataContext()));

  331.             // Create the XML SAX parser factory
  332.             final SAXParserFactory factory = SAXParserFactory.newInstance();

  334.             // Build the parser and read the xml file
  335.             final SAXParser parser = factory.newSAXParser();
  336.             parser.parse(stream, handler);

  338.             // Get the content of the file
  339.             final TDMFile tdmFile = handler.parseInfo.tdmFile;

  341.             // Check time systems consistency
  342.             tdmFile.checkTimeSystems();

  344.             return tdmFile;
  345.         } catch (SAXException se) {
  346.             final OrekitException oe;
  347.             if (se.getException() != null && se.getException() instanceof OrekitException) {
  348.                 oe = (OrekitException) se.getException();
  349.             } else {
  350.                 oe = new OrekitException(se, new DummyLocalizable(se.getMessage()));
  351.             }
  352.             throw oe;
  353.         } catch (ParserConfigurationException | IOException e) {
  354.             // throw caught exception as an OrekitException
  355.             throw new OrekitException(e, new DummyLocalizable(e.getMessage()));
  356.         }
  357.     }

  359.     /** Private class used to stock TDM parsing info.
  360.      * @author sports
  361.      */
  362.     private static class ParseInfo {

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

  367.         /** IERS Conventions. */
  368.         private final  IERSConventions conventions;

  370.         /** Indicator for simple or accurate EOP interpolation. */
  371.         private final  boolean simpleEOP;

  373.         /** Data context. */
  374.         private final DataContext dataContext;

  376.         /** Name of the file. */
  377.         private String fileName;

  379.         /** Current Observation Block being parsed. */
  380.         private TDMFile.ObservationsBlock currentObservationsBlock;

  382.         /** Current line number. */
  383.         private int lineNumber;

  385.         /** Current parsed line. */
  386.         private String line;

  388.         /** TDMFile object being filled. */
  389.         private TDMFile tdmFile;

  391.         /** Key value of the current line being read. */
  392.         private KeyValue keyValue;

  394.         /** Temporary stored comments. */
  395.         private List<String> commentTmp;

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

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

  403.         /** Complete constructor.
  404.          * @param missionReferenceDate reference date for Mission Elapsed Time or Mission Relative Time time systems
  405.          * @param conventions IERS Conventions
  406.          * @param simpleEOP if true, tidal effects are ignored when interpolating EOP
  407.          * @param fileName the name of the file being parsed
  408.          * @param dataContext used to retrieve frames, time scales, etc.
  409.          */
  410.         private ParseInfo(final AbsoluteDate missionReferenceDate,
  411.                           final IERSConventions conventions,
  412.                           final boolean simpleEOP,
  413.                           final String fileName,
  414.                           final DataContext dataContext) {
  415.             this.missionReferenceDate = missionReferenceDate;
  416.             this.conventions          = conventions;
  417.             this.simpleEOP            = simpleEOP;
  418.             this.fileName             = fileName;
  419.             this.dataContext = dataContext;
  420.             this.lineNumber = 0;
  421.             this.line = "";
  422.             this.tdmFile = new TDMFile();
  423.             this.commentTmp = new ArrayList<String>();
  424.             this.currentObservationsBlock = null;
  425.             this.parsingMetaData = false;
  426.             this.parsingData     = false;
  427.         }

  429.         /** Parse a meta-data entry.<p>
  430.          * key = value (KEYVALUE file format)<p>
  431.          * <&lt;key>value&lt;/key> (XML file format)
  432.          */
  433.         private void parseMetaDataEntry() {

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

  437.             try {
  438.                 switch (keyValue.getKeyword()) {
  439.                     case TIME_SYSTEM:
  440.                         // Read the time system and ensure that it is supported by Orekit
  441.                         if (!CcsdsTimeScale.contains(keyValue.getValue())) {
  442.                             throw new OrekitException(OrekitMessages.CCSDS_TIME_SYSTEM_NOT_IMPLEMENTED,
  443.                                                       keyValue.getValue());
  444.                         }
  445.                         final CcsdsTimeScale timeSystem =
  446.                                         CcsdsTimeScale.valueOf(keyValue.getValue());
  447.                         metaData.setTimeSystem(timeSystem);

  449.                         // Convert start/stop time to AbsoluteDate if they have been read already
  450.                         if (metaData.getStartTimeString() != null) {
  451.                             metaData.setStartTime(parseDate(metaData.getStartTimeString(), timeSystem));
  452.                         }
  453.                         if (metaData.getStopTimeString() != null) {
  454.                             metaData.setStopTime(parseDate(metaData.getStopTimeString(), timeSystem));
  455.                         }
  456.                         break;

  458.                     case START_TIME:
  459.                         // Set the start time as a String first
  460.                         metaData.setStartTimeString(keyValue.getValue());

  462.                         // If time system has already been defined, convert the start time to an AbsoluteDate
  463.                         if (metaData.getTimeSystem() != null) {
  464.                             metaData.setStartTime(parseDate(keyValue.getValue(), metaData.getTimeSystem()));
  465.                         }
  466.                         break;

  468.                     case STOP_TIME:
  469.                         // Set the stop time as a String first
  470.                         metaData.setStopTimeString(keyValue.getValue());

  472.                         // If time system has already been defined, convert the start time to an AbsoluteDate
  473.                         if (metaData.getTimeSystem() != null) {
  474.                             metaData.setStopTime(parseDate(keyValue.getValue(), metaData.getTimeSystem()));
  475.                         }
  476.                         break;

  478.                     case PARTICIPANT_1: case PARTICIPANT_2: case PARTICIPANT_3:
  479.                     case PARTICIPANT_4: case PARTICIPANT_5:
  480.                         // Get the participant number
  481.                         String key = keyValue.getKey();
  482.                         int participantNumber = Integer.parseInt(key.substring(key.length() - 1));

  484.                         // Add the tuple to the map
  485.                         metaData.addParticipant(participantNumber, keyValue.getValue());
  486.                         break;

  488.                     case MODE:
  489.                         metaData.setMode(keyValue.getValue());
  490.                         break;

  492.                     case PATH:
  493.                         metaData.setPath(keyValue.getValue());
  494.                         break;

  496.                     case PATH_1:
  497.                         metaData.setPath1(keyValue.getValue());
  498.                         break;

  500.                     case PATH_2:
  501.                         metaData.setPath2(keyValue.getValue());
  502.                         break;

  504.                     case TRANSMIT_BAND:
  505.                         metaData.setTransmitBand(keyValue.getValue());
  506.                         break;

  508.                     case RECEIVE_BAND:
  509.                         metaData.setReceiveBand(keyValue.getValue());
  510.                         break;

  512.                     case TURNAROUND_NUMERATOR:
  513.                         metaData.setTurnaroundNumerator(keyValue.getIntegerValue());
  514.                         break;

  516.                     case TURNAROUND_DENOMINATOR:
  517.                         metaData.setTurnaroundDenominator(keyValue.getIntegerValue());
  518.                         break;

  520.                     case TIMETAG_REF:
  521.                         metaData.setTimetagRef(keyValue.getValue());
  522.                         break;

  524.                     case INTEGRATION_INTERVAL:
  525.                         metaData.setIntegrationInterval(keyValue.getDoubleValue());
  526.                         break;

  528.                     case INTEGRATION_REF:
  529.                         metaData.setIntegrationRef(keyValue.getValue());
  530.                         break;

  532.                     case FREQ_OFFSET:
  533.                         metaData.setFreqOffset(keyValue.getDoubleValue());
  534.                         break;

  536.                     case RANGE_MODE:
  537.                         metaData.setRangeMode(keyValue.getValue());
  538.                         break;

  540.                     case RANGE_MODULUS:
  541.                         metaData.setRangeModulus(keyValue.getDoubleValue());
  542.                         break;

  544.                     case RANGE_UNITS:
  545.                         metaData.setRangeUnits(keyValue.getValue());
  546.                         break;

  548.                     case ANGLE_TYPE:
  549.                         metaData.setAngleType(keyValue.getValue());
  550.                         break;

  552.                     case REFERENCE_FRAME:
  553.                         metaData.setReferenceFrameString(keyValue.getValue());
  554.                         metaData.setReferenceFrame(parseCCSDSFrame(keyValue.getValue())
  555.                                 .getFrame(this.conventions, this.simpleEOP, dataContext));
  556.                         break;

  558.                     case TRANSMIT_DELAY_1: case TRANSMIT_DELAY_2: case TRANSMIT_DELAY_3:
  559.                     case TRANSMIT_DELAY_4: case TRANSMIT_DELAY_5:
  560.                         // Get the participant number
  561.                         key = keyValue.getKey();
  562.                         participantNumber = Integer.parseInt(key.substring(key.length() - 1));

  564.                         // Add the tuple to the map
  565.                         metaData.addTransmitDelay(participantNumber, keyValue.getDoubleValue());
  566.                         break;

  568.                     case RECEIVE_DELAY_1: case RECEIVE_DELAY_2: case RECEIVE_DELAY_3:
  569.                     case RECEIVE_DELAY_4: case RECEIVE_DELAY_5:
  570.                         // Get the participant number
  571.                         key = keyValue.getKey();
  572.                         participantNumber = Integer.parseInt(key.substring(key.length() - 1));

  574.                         // Add the tuple to the map
  575.                         metaData.addReceiveDelay(participantNumber, keyValue.getDoubleValue());
  576.                         break;

  578.                     case DATA_QUALITY:
  579.                         metaData.setDataQuality(keyValue.getValue());
  580.                         break;

  582.                     case CORRECTION_ANGLE_1:
  583.                         metaData.setCorrectionAngle1(keyValue.getDoubleValue());
  584.                         break;

  586.                     case CORRECTION_ANGLE_2:
  587.                         metaData.setCorrectionAngle2(keyValue.getDoubleValue());
  588.                         break;

  590.                     case CORRECTION_DOPPLER:
  591.                         metaData.setCorrectionDoppler(keyValue.getDoubleValue());
  592.                         break;

  594.                     case CORRECTION_RANGE:
  595.                         metaData.setCorrectionRange(keyValue.getDoubleValue());
  596.                         break;

  598.                     case CORRECTION_RECEIVE:
  599.                         metaData.setCorrectionReceive(keyValue.getDoubleValue());
  600.                         break;

  602.                     case CORRECTION_TRANSMIT:
  603.                         metaData.setCorrectionTransmit(keyValue.getDoubleValue());
  604.                         break;

  606.                     case CORRECTIONS_APPLIED:
  607.                         metaData.setCorrectionsApplied(keyValue.getValue());
  608.                         break;

  610.                     default:
  611.                         throw new OrekitException(OrekitMessages.CCSDS_UNEXPECTED_KEYWORD, lineNumber, fileName, line);
  612.                 }
  613.             } catch (NumberFormatException nfe) {
  614.                 throw new OrekitException(OrekitMessages.UNABLE_TO_PARSE_LINE_IN_FILE,
  615.                                           lineNumber, fileName, line);
  616.             }
  617.         }

  619.         /** Parse a CCSDS frame.
  620.          * @param frameName name of the frame, as the value of a CCSDS key=value line
  621.          * @return CCSDS frame corresponding to the name
  622.          */
  623.         private CCSDSFrame parseCCSDSFrame(final String frameName) {
  624.             return CCSDSFrame.valueOf(frameName.replaceAll("-", ""));
  625.         }

  627.         /** Parse a date.
  628.          * @param date date to parse, as the value of a CCSDS key=value line
  629.          * @param timeSystem time system to use
  630.          * @return parsed date
  631.          */
  632.         private AbsoluteDate parseDate(final String date, final CcsdsTimeScale timeSystem) {
  633.             return timeSystem.parseDate(date, conventions, missionReferenceDate,
  634.                     dataContext.getTimeScales());
  635.         }
  636.     }

  638.     /** Handler for parsing KEYVALUE file formats. */
  639.     private static class KeyValueHandler {

  641.         /** ParseInfo object. */
  642.         private ParseInfo parseInfo;

  644.         /** Simple constructor.
  645.          * @param parseInfo ParseInfo object
  646.          */
  647.         KeyValueHandler(final ParseInfo parseInfo) {
  648.             this.parseInfo       = parseInfo;
  649.         }

  651.         /**
  652.          * Parse an observation data line and add its content to the Observations Block
  653.          * block.
  654.          *
  655.          */
  656.         private void parseObservationsDataLine() {

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

  663.             // Check that there are 2 fields in the value of the key
  664.             if (fields.length != 2) {
  665.                 throw new OrekitException(OrekitMessages.CCSDS_TDM_INCONSISTENT_DATA_LINE,
  666.                                           parseInfo.lineNumber, parseInfo.fileName, parseInfo.line);
  667.             }

  669.             // Convert the date to an AbsoluteDate object (OrekitException if it fails)
  670.             final AbsoluteDate epoch = parseInfo.parseDate(fields[0], parseInfo.currentObservationsBlock.getMetaData().getTimeSystem());
  671.             final double measurement;
  672.             try {
  673.                 // Convert the value to double (NumberFormatException if it fails)
  674.                 measurement = Double.parseDouble(fields[1]);
  675.             } catch (NumberFormatException nfe) {
  676.                 throw new OrekitException(OrekitMessages.UNABLE_TO_PARSE_LINE_IN_FILE,
  677.                                           parseInfo.lineNumber, parseInfo.fileName, parseInfo.line);
  678.             }

  680.             // Adds the observation to current observation block
  681.             parseInfo.currentObservationsBlock.addObservation(parseInfo.keyValue.getKeyword().name(),
  682.                                                        epoch,
  683.                                                        measurement);
  684.         }

  686.         /** Parse a CCSDS Tracking Data Message with KEYVALUE format.
  687.          * @param stream stream containing message
  688.          * @param fileName name of the file containing the message (for error messages)
  689.          * @return parsed file content in a TDMFile object
  690.          */
  691.         public TDMFile parse(final InputStream stream, final String fileName) {
  692.             try (BufferedReader reader = new BufferedReader(new InputStreamReader(stream, StandardCharsets.UTF_8))) {
  693.                 try {
  694.                     // Initialize internal TDMFile
  695.                     final TDMFile tdmFile = parseInfo.tdmFile;

  697.                     // Read the file
  698.                     for (String line = reader.readLine(); line != null; line = reader.readLine()) {
  699.                         ++parseInfo.lineNumber;
  700.                         if (line.trim().length() == 0) {
  701.                             continue;
  702.                         }
  703.                         parseInfo.line = line;
  704.                         parseInfo.keyValue = new KeyValue(parseInfo.line, parseInfo.lineNumber, parseInfo.fileName);
  705.                         if (parseInfo.keyValue.getKeyword() == null) {
  706.                             throw new OrekitException(OrekitMessages.CCSDS_UNEXPECTED_KEYWORD, parseInfo.lineNumber, parseInfo.fileName, parseInfo.line);
  707.                         }
  708.                         switch (parseInfo.keyValue.getKeyword()) {

  710.                             // Header entries
  711.                             case CCSDS_TDM_VERS:
  712.                                 // Set CCSDS TDM version
  713.                                 tdmFile.setFormatVersion(parseInfo.keyValue.getDoubleValue());
  714.                                 break;

  716.                             case CREATION_DATE:
  717.                                 // Save current comment in header
  718.                                 tdmFile.setHeaderComment(parseInfo.commentTmp);
  719.                                 parseInfo.commentTmp.clear();
  720.                                 // Set creation date
  721.                                 tdmFile.setCreationDate(new AbsoluteDate(
  722.                                         parseInfo.keyValue.getValue(),
  723.                                         parseInfo.dataContext.getTimeScales().getUTC()));
  724.                                 break;

  726.                             case ORIGINATOR:
  727.                                 // Set originator
  728.                                 tdmFile.setOriginator(parseInfo.keyValue.getValue());
  729.                                 break;

  731.                                 // Comments
  732.                             case COMMENT:
  733.                                 parseInfo.commentTmp.add(parseInfo.keyValue.getValue());
  734.                                 break;

  736.                                 // Start/Strop keywords
  737.                             case META_START:
  738.                                 // Add an observation block and set the last observation block to the current
  739.                                 tdmFile.addObservationsBlock();
  740.                                 parseInfo.currentObservationsBlock = tdmFile.getObservationsBlocks().get(tdmFile.getObservationsBlocks().size() - 1);
  741.                                 // Indicate the start of meta-data parsing for this block
  742.                                 parseInfo.parsingMetaData = true;
  743.                                 break;

  745.                             case META_STOP:
  746.                                 // Save current comment in current meta-data comment
  747.                                 parseInfo.currentObservationsBlock.getMetaData().setComment(parseInfo.commentTmp);
  748.                                 parseInfo.commentTmp.clear();
  749.                                 // Indicate the end of meta-data parsing for this block
  750.                                 parseInfo.parsingMetaData = false;
  751.                                 break;

  753.                             case DATA_START:
  754.                                 // Indicate the start of data parsing for this block
  755.                                 parseInfo.parsingData = true;
  756.                                 break;

  758.                             case DATA_STOP:
  759.                                 // Save current comment in current Observation Block comment
  760.                                 parseInfo.currentObservationsBlock.setObservationsComment(parseInfo.commentTmp);
  761.                                 parseInfo.commentTmp.clear();
  762.                                 // Indicate the end of data parsing for this block
  763.                                 parseInfo.parsingData = false;
  764.                                 break;

  766.                             default:
  767.                                 // Parse a line that does not display the previous keywords
  768.                                 if ((parseInfo.currentObservationsBlock != null) &&
  769.                                      (parseInfo.parsingData || parseInfo.parsingMetaData)) {
  770.                                     if (parseInfo.parsingMetaData) {
  771.                                         // Parse a meta-data line
  772.                                         parseInfo.parseMetaDataEntry();
  773.                                     } else {
  774.                                         // Parse an observation data line
  775.                                         this.parseObservationsDataLine();
  776.                                     }
  777.                                 } else {
  778.                                     throw new OrekitException(OrekitMessages.CCSDS_UNEXPECTED_KEYWORD,
  779.                                                               parseInfo.lineNumber, parseInfo.fileName, parseInfo.line);
  780.                                 }
  781.                                 break;
  782.                         }
  783.                     }
  784.                     // Check time systems consistency before returning the parsed content
  785.                     tdmFile.checkTimeSystems();
  786.                     return tdmFile;
  787.                 } catch (IOException ioe) {
  788.                     throw new OrekitException(ioe, new DummyLocalizable(ioe.getMessage()));
  789.                 }
  790.             } catch (IOException ioe) {
  791.                 throw new OrekitException(ioe, new DummyLocalizable(ioe.getMessage()));
  792.             }
  793.         }
  794.     }

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

  799.         /** ParseInfo object. */
  800.         private ParseInfo parseInfo;

  802.         /** Locator used to get current line number. */
  803.         private Locator locator;

  805.         /** Current keyword being read. */
  806.         private Keyword currentKeyword;

  808.         /** Current observation keyword being read. */
  809.         private Keyword currentObservationKeyword;

  811.         /** Current observation epoch being read. */
  812.         private AbsoluteDate currentObservationEpoch;

  814.         /** Current observation measurement being read. */
  815.         private double currentObservationMeasurement;

  817.         /** Simple constructor.
  818.          * @param parseInfo ParseInfo object
  819.          */
  820.         XMLHandler(final ParseInfo parseInfo) {
  821.             this.parseInfo      = parseInfo;
  822.             this.locator        = null;
  823.             this.currentKeyword = null;
  824.             this.currentObservationKeyword      = null;
  825.             this.currentObservationEpoch        = null;
  826.             this.currentObservationMeasurement  = Double.NaN;
  827.         }

  829.         @Override
  830.         public void setDocumentLocator(final Locator documentLocator) {
  831.             this.locator = documentLocator;
  832.         }

  834.         /**
  835.          * Extract the content of an element.
  836.          *
  837.          * @param ch the characters
  838.          * @param start the index of the first character of the desired content
  839.          * @param length the length of the content
  840.          * @throws SAXException in case of an error.
  841.          *
  842.          * @see org.xml.sax.helpers.DefaultHandler#characters(char[], int, int)
  843.          */
  844.         @Override
  845.         public void characters(final char[] ch, final int start, final int length) throws SAXException
  846.         {
  847.             try {
  848.                 // currentKeyword is set to null in function endElement every time an end tag is parsed.
  849.                 // Thus only the characters between a start and an end tags are parsed.
  850.                 if (currentKeyword != null) {
  851.                     // Store the info in a KeyValue object so that we can use the common functions of parseInfo
  852.                     // The SAX locator does not allow the retrieving of the line
  853.                     // So a pseudo-line showing the keyword is reconstructed
  854.                     final String value = new String(ch, start, length);
  855.                     parseInfo.line = "<" + currentKeyword.name() + ">" + value + "<" + "/" + currentKeyword.name() + ">";
  856.                     parseInfo.lineNumber = locator.getLineNumber();
  857.                     parseInfo.keyValue = new KeyValue(currentKeyword, value, parseInfo.line, parseInfo.lineNumber, parseInfo.fileName);

  859.                     // Scan the keyword
  860.                     switch (currentKeyword) {

  862.                         case CREATION_DATE:
  863.                             // Set creation date
  864.                             parseInfo.tdmFile.setCreationDate(new AbsoluteDate(
  865.                                     parseInfo.keyValue.getValue(),
  866.                                     parseInfo.dataContext.getTimeScales().getUTC()));
  867.                             break;

  869.                         case ORIGINATOR:
  870.                             // Set originator
  871.                             parseInfo.tdmFile.setOriginator(parseInfo.keyValue.getValue());
  872.                             break;

  874.                         case COMMENT:
  875.                             // Comments
  876.                             parseInfo.commentTmp.add(parseInfo.keyValue.getValue());
  877.                             break;

  879.                         case tdm: case header: case body: case segment:
  880.                         case metadata: case data:case observation:
  881.                             // Do nothing for this tags
  882.                             break;

  884.                         default:
  885.                             // Parse a line that does not display the previous keywords
  886.                             if ((parseInfo.currentObservationsBlock != null) &&
  887.                                  (parseInfo.parsingData || parseInfo.parsingMetaData)) {
  888.                                 if (parseInfo.parsingMetaData) {
  889.                                     // Call meta-data parsing
  890.                                     parseInfo.parseMetaDataEntry();
  891.                                 } else if (parseInfo.parsingData) {
  892.                                     // Call data parsing
  893.                                     parseObservationDataLine();
  894.                                 }
  895.                             } else {
  896.                                 throw new OrekitException(OrekitMessages.CCSDS_UNEXPECTED_KEYWORD,
  897.                                                           parseInfo.lineNumber, parseInfo.fileName, parseInfo.line);
  898.                             }
  899.                             break;
  900.                     }
  901.                 }
  902.             } catch (OrekitException e) {
  903.                 // Re-throw the exception as a SAXException
  904.                 throw new SAXException(e);
  905.             }
  906.         }

  908.         /**
  909.          * Detect the beginning of an element.
  910.          *
  911.          * @param uri The Namespace URI, or the empty string if the element has no Namespace URI or if Namespace processing is not being performed.
  912.          * @param localName The local name (without prefix), or the empty string if Namespace processing is not being performed.
  913.          * @param qName The qualified name (with prefix), or the empty string if qualified names are not available.
  914.          * @param attributes The attributes attached to the element. If there are no attributes, it shall be an empty Attributes object.
  915.          * @throws SAXException in case of an error
  916.          *
  917.          * @see org.xml.sax.helpers.DefaultHandler#startElement(java.lang.String, java.lang.String, java.lang.String, org.xml.sax.Attributes)
  918.          */
  919.         @Override
  920.         public void startElement(final String uri, final String localName, final String qName, final Attributes attributes) throws SAXException
  921.         {
  922.             // Check if the start element belongs to the standard keywords
  923.             try
  924.             {
  925.                 try {
  926.                     this.currentKeyword = Keyword.valueOf(qName);
  927.                 } catch (IllegalArgumentException e) {
  928.                     throw new OrekitException(OrekitMessages.CCSDS_UNEXPECTED_KEYWORD,
  929.                                               locator.getLineNumber(),
  930.                                               parseInfo.fileName,
  931.                                               "<" + qName + ">");
  932.                 }
  933.                 switch (currentKeyword) {
  934.                     case tdm:
  935.                         // Get the version number
  936.                         parseInfo.tdmFile.setFormatVersion(Double.parseDouble(attributes.getValue("version")));
  937.                         break;

  939.                     case observation:
  940.                         // Re-initialize the stored observation's attributes
  941.                         this.currentObservationKeyword     = null;
  942.                         this.currentObservationEpoch       = null;
  943.                         this.currentObservationMeasurement = Double.NaN;
  944.                         break;

  946.                     case segment:
  947.                         // Add an observation block and set the last observation block to the current
  948.                         final TDMFile tdmFile = parseInfo.tdmFile;
  949.                         tdmFile.addObservationsBlock();
  950.                         parseInfo.currentObservationsBlock = tdmFile.getObservationsBlocks().get(tdmFile.getObservationsBlocks().size() - 1);
  951.                         break;

  953.                     case metadata:
  954.                         // Indicate the start of meta-data parsing for this block
  955.                         parseInfo.parsingMetaData = true;
  956.                         break;

  958.                     case data:
  959.                         // Indicate the start of data parsing for this block
  960.                         parseInfo.parsingData = true;
  961.                         break;

  963.                     default:
  964.                         // Ignore the element.
  965.                         break;
  966.                 }
  967.             }
  968.             catch (IllegalArgumentException | OrekitException e)
  969.             {
  970.                 throw new SAXException(e);
  971.             }
  972.         }

  974.         /**
  975.          * Detect the end of an element and remove the stored keyword.
  976.          *
  977.          * @param uri The Namespace URI, or the empty string if the element has no Namespace URI or if Namespace processing is not being performed.
  978.          * @param localName The local name (without prefix), or the empty string if Namespace processing is not being performed.
  979.          * @param qName The qualified name (with prefix), or the empty string if qualified names are not available.
  980.          * @throws SAXException in case of an error
  981.          *
  982.          * @see org.xml.sax.helpers.DefaultHandler#endElement(java.lang.String, java.lang.String, java.lang.String)
  983.          */
  984.         @Override
  985.         public void endElement(final String uri, final String localName, final String qName) throws SAXException
  986.         {
  987.             // check if the start element belongs to the standard keywords
  988.             try
  989.             {
  990.                 // Set the stored keyword to null
  991.                 currentKeyword = null;
  992.                 // Ending keyword
  993.                 final Keyword endKeyword;
  994.                 try {
  995.                     endKeyword = Keyword.valueOf(qName);
  996.                 } catch (IllegalArgumentException e) {
  997.                     throw new OrekitException(OrekitMessages.CCSDS_UNEXPECTED_KEYWORD,
  998.                                               locator.getLineNumber(),
  999.                                               parseInfo.fileName,
  1000.                                               "</" + qName + ">");
  1001.                 }
  1002.                 switch (endKeyword) {

  1004.                     case header:
  1005.                         // Save header comment
  1006.                         parseInfo.tdmFile.setHeaderComment(parseInfo.commentTmp);
  1007.                         parseInfo.commentTmp.clear();
  1008.                         break;

  1010.                     case observation:
  1011.                         // Check that stored observation's attributes were all found
  1012.                         if (currentObservationKeyword == null         ||
  1013.                             currentObservationEpoch == null           ||
  1014.                             Double.isNaN(currentObservationMeasurement)) {
  1015.                             throw new OrekitException(OrekitMessages.CCSDS_TDM_XML_INCONSISTENT_DATA_BLOCK,
  1016.                                                       locator.getLineNumber(),
  1017.                                                       parseInfo.fileName);
  1018.                         } else {
  1019.                             // Add current observation
  1020.                             parseInfo.currentObservationsBlock.addObservation(currentObservationKeyword.name(),
  1021.                                                                               currentObservationEpoch,
  1022.                                                                               currentObservationMeasurement);
  1023.                         }
  1024.                         break;

  1026.                     case segment:
  1027.                         // Do nothing
  1028.                         break;

  1030.                     case metadata:
  1031.                         // Save current comment in current meta-data comment
  1032.                         parseInfo.currentObservationsBlock.getMetaData().setComment(parseInfo.commentTmp);
  1033.                         parseInfo.commentTmp.clear();
  1034.                         // Indicate the end of meta-data parsing for this block
  1035.                         parseInfo.parsingMetaData = false;
  1036.                         break;

  1038.                     case data:
  1039.                         // Save current comment in current Observation Block comment
  1040.                         parseInfo.currentObservationsBlock.setObservationsComment(parseInfo.commentTmp);
  1041.                         parseInfo.commentTmp.clear();
  1042.                         // Indicate the end of data parsing for this block
  1043.                         parseInfo.parsingData = false;
  1044.                         break;

  1046.                     default:
  1047.                         // Ignore the element.
  1048.                 }
  1049.             }
  1050.             catch (IllegalArgumentException | OrekitException e)
  1051.             {
  1052.                 throw new SAXException(e);
  1053.             }
  1054.         }

  1056.         @Override
  1057.         public InputSource resolveEntity(final String publicId, final String systemId) {
  1058.             // disable external entities
  1059.             return new InputSource();
  1060.         }

  1062.         /** Parse a line in an observation data block.
  1063.          */
  1064.         private void parseObservationDataLine() {

  1066.             // Parse an observation line
  1067.             // An XML observation line should consist in the string "<KEYWORD>value</KEYWORD>
  1068.             // Each observation block should display:
  1069.             //  - One line with the keyword EPOCH;
  1070.             //  - One line with a specific data keyword
  1071.             switch(currentKeyword) {
  1072.                 case EPOCH:
  1073.                     // Convert the date to an AbsoluteDate object (OrekitException if it fails)
  1074.                     currentObservationEpoch = parseInfo.parseDate(parseInfo.keyValue.getValue(),
  1075.                                                        parseInfo.currentObservationsBlock.getMetaData().getTimeSystem());
  1076.                     break;
  1077.                 default:
  1078.                     try {
  1079.                         // Update current observation keyword
  1080.                         currentObservationKeyword = currentKeyword;
  1081.                         // Convert the value to double (NumberFormatException if it fails)
  1082.                         currentObservationMeasurement = Double.parseDouble(parseInfo.keyValue.getValue());
  1083.                     } catch (NumberFormatException nfe) {
  1084.                         throw new OrekitException(OrekitMessages.UNABLE_TO_PARSE_LINE_IN_FILE,
  1085.                                                   parseInfo.lineNumber, parseInfo.fileName, parseInfo.line);
  1086.                     }
  1087.                     break;
  1088.             }
  1089.         }
  1090.     }
  1091. }
Created with JaCoCo 0.8.5.201910111838