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 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.nio.charset.StandardCharsets;
  25. import java.util.ArrayList;
  26. import java.util.List;
  27. import java.util.Locale;
  28. import java.util.regex.Pattern;

  30. import javax.xml.parsers.ParserConfigurationException;
  31. import javax.xml.parsers.SAXParser;
  32. import javax.xml.parsers.SAXParserFactory;

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


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

  76.     /** Pattern for dash. */
  77.     private static final Pattern DASH = Pattern.compile("-");

  79.     /** Pattern for delimiting regular expressions. */
  80.     private static final Pattern SEPARATOR = Pattern.compile("\\s+");

  82.     /** Enumerate for the format. */
  83.     public enum TDMFileFormat {

  85.         /** Keyvalue (text file with Key = Value lines). */
  86.         KEYVALUE,

  88.         /** XML format. */
  89.         XML,

  91.         /** UKNOWN file format, default format, throw an Orekit Exception if kept this way. */
  92.         UNKNOWN;
  93.     }

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

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

  101.     /** IERS Conventions. */
  102.     private final  IERSConventions conventions;

  104.     /** Indicator for simple or accurate EOP interpolation. */
  105.     private final  boolean simpleEOP;

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

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

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

  167.     /** Set file format.
  168.      * @param newFileFormat The format of the file: KEYVALUE or XML
  169.      * @return a new instance, with file format set to newFileFormat
  170.      * @see #getFileFormat()
  171.      */
  172.     public TDMParser withFileFormat(final TDMFileFormat newFileFormat) {
  173.         return new TDMParser(newFileFormat, getMissionReferenceDate(), getConventions(),
  174.                 isSimpleEOP(), getDataContext());
  175.     }

  177.     /** Get file format.
  178.      * @return the file format
  179.      * @see #withFileFormat(TDMFileFormat)
  180.      */
  181.     public TDMFileFormat getFileFormat() {
  182.         return fileFormat;
  183.     }

  185.     /** Set initial date.
  186.      * @param newMissionReferenceDate mission reference date to use while parsing
  187.      * @return a new instance, with mission reference date replaced
  188.      * @see #getMissionReferenceDate()
  189.      */
  190.     public TDMParser withMissionReferenceDate(final AbsoluteDate newMissionReferenceDate) {
  191.         return new TDMParser(getFileFormat(), newMissionReferenceDate, getConventions(),
  192.                 isSimpleEOP(), getDataContext());
  193.     }

  195.     /** Get initial date.
  196.      * @return mission reference date to use while parsing
  197.      * @see #withMissionReferenceDate(AbsoluteDate)
  198.      */
  199.     public AbsoluteDate getMissionReferenceDate() {
  200.         return missionReferenceDate;
  201.     }

  203.     /** Set IERS conventions.
  204.      * @param newConventions IERS conventions to use while parsing
  205.      * @return a new instance, with IERS conventions replaced
  206.      * @see #getConventions()
  207.      */
  208.     public TDMParser withConventions(final IERSConventions newConventions) {
  209.         return new TDMParser(getFileFormat(), getMissionReferenceDate(), newConventions,
  210.                 isSimpleEOP(), getDataContext());
  211.     }

  213.     /** Get IERS conventions.
  214.      * @return IERS conventions to use while parsing
  215.      * @see #withConventions(IERSConventions)
  216.      */
  217.     public IERSConventions getConventions() {
  218.         return conventions;
  219.     }

  221.     /** Set EOP interpolation method.
  222.      * @param newSimpleEOP if true, tidal effects are ignored when interpolating EOP
  223.      * @return a new instance, with EOP interpolation method replaced
  224.      * @see #isSimpleEOP()
  225.      */
  226.     public TDMParser withSimpleEOP(final boolean newSimpleEOP) {
  227.         return new TDMParser(getFileFormat(), getMissionReferenceDate(), getConventions(),
  228.                 newSimpleEOP, getDataContext());
  229.     }

  231.     /** Get EOP interpolation method.
  232.      * @return true if tidal effects are ignored when interpolating EOP
  233.      * @see #withSimpleEOP(boolean)
  234.      */
  235.     public boolean isSimpleEOP() {
  236.         return simpleEOP;
  237.     }

  239.     /**
  240.      * Get the data context.
  241.      *
  242.      * @return the data context used for retrieving frames, time scales, etc.
  243.      */
  244.     public DataContext getDataContext() {
  245.         return dataContext;
  246.     }

  248.     /**
  249.      * Set the data context.
  250.      *
  251.      * @param newDataContext used for retrieving frames, time scales, etc.
  252.      * @return a new instance with the data context replaced.
  253.      */
  254.     public TDMParser withDataContext(final DataContext newDataContext) {
  255.         return new TDMParser(getFileFormat(), getMissionReferenceDate(), getConventions(),
  256.                 isSimpleEOP(), newDataContext);
  257.     }

  259.     /** Parse a CCSDS Tracking Data Message.
  260.      * @param fileName name of the file containing the message
  261.      * @return parsed file content in a TDMFile object
  262.      */
  263.     public TDMFile parse(final String fileName) {
  264.         try (InputStream stream = new FileInputStream(fileName)) {
  265.             return parse(stream, fileName);
  266.         } catch (IOException ioe) {
  267.             throw new OrekitException(OrekitMessages.UNABLE_TO_FIND_FILE, fileName);
  268.         }
  269.     }

  271.     /** Parse a CCSDS Tracking Data Message.
  272.      * @param stream stream containing message
  273.      * @return parsed file content in a TDMFile object
  274.      */
  275.     public TDMFile parse(final InputStream stream) {
  276.         return parse(stream, "<unknown>");
  277.     }

  279.     /** Parse a CCSDS Tracking Data Message.
  280.      * @param stream stream containing message
  281.      * @param fileName name of the file containing the message (for error messages)
  282.      * @return parsed file content in a TDMFile object
  283.      */
  284.     public TDMFile parse(final InputStream stream, final String fileName) {

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

  308.     /** Parse a CCSDS Tracking Data Message with KEYVALUE format.
  309.      * @param stream stream containing message
  310.      * @param fileName name of the file containing the message (for error messages)
  311.      * @return parsed file content in a TDMFile object
  312.      */
  313.     public TDMFile parseKeyValue(final InputStream stream, final String fileName) {

  315.         final KeyValueHandler handler = new KeyValueHandler(new ParseInfo(this.getMissionReferenceDate(),
  316.                                                                     this.getConventions(),
  317.                                                                     this.isSimpleEOP(),
  318.                                                                     fileName,
  319.                                                                     getDataContext()));
  320.         return handler.parse(stream, fileName);
  321.     }



  325.     /** Parse a CCSDS Tracking Data Message with XML format.
  326.      * @param stream stream containing message
  327.      * @param fileName name of the file containing the message (for error messages)
  328.      * @return parsed file content in a TDMFile object
  329.      */
  330.     public TDMFile parseXml(final InputStream stream, final String fileName) {
  331.         try {
  332.             // Create the handler
  333.             final XMLHandler handler = new XMLHandler(new ParseInfo(this.getMissionReferenceDate(),
  334.                                                                     this.getConventions(),
  335.                                                                     this.isSimpleEOP(),
  336.                                                                     fileName,
  337.                                                                     getDataContext()));

  339.             // Create the XML SAX parser factory
  340.             final SAXParserFactory factory = SAXParserFactory.newInstance();

  342.             // Build the parser and read the xml file
  343.             final SAXParser parser = factory.newSAXParser();
  344.             parser.parse(stream, handler);

  346.             // Get the content of the file
  347.             final TDMFile tdmFile = handler.parseInfo.tdmFile;

  349.             // Check time systems consistency
  350.             tdmFile.checkTimeSystems();

  352.             return tdmFile;
  353.         } catch (SAXException se) {
  354.             final OrekitException oe;
  355.             if (se.getException() != null && se.getException() instanceof OrekitException) {
  356.                 oe = (OrekitException) se.getException();
  357.             } else {
  358.                 oe = new OrekitException(se, new DummyLocalizable(se.getMessage()));
  359.             }
  360.             throw oe;
  361.         } catch (ParserConfigurationException | IOException e) {
  362.             // throw caught exception as an OrekitException
  363.             throw new OrekitException(e, new DummyLocalizable(e.getMessage()));
  364.         }
  365.     }

  367.     /** Private class used to stock TDM parsing info.
  368.      * @author sports
  369.      */
  370.     private static class ParseInfo {

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

  375.         /** IERS Conventions. */
  376.         private final  IERSConventions conventions;

  378.         /** Indicator for simple or accurate EOP interpolation. */
  379.         private final  boolean simpleEOP;

  381.         /** Data context. */
  382.         private final DataContext dataContext;

  384.         /** Name of the file. */
  385.         private String fileName;

  387.         /** Current Observation Block being parsed. */
  388.         private TDMFile.ObservationsBlock currentObservationsBlock;

  390.         /** Current line number. */
  391.         private int lineNumber;

  393.         /** Current parsed line. */
  394.         private String line;

  396.         /** TDMFile object being filled. */
  397.         private TDMFile tdmFile;

  399.         /** Key value of the current line being read. */
  400.         private KeyValue keyValue;

  402.         /** Temporary stored comments. */
  403.         private List<String> commentTmp;

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

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

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

  437.         /** Parse a meta-data entry.<p>
  438.          * key = value (KEYVALUE file format)<p>
  439.          * <&lt;key>value&lt;/key> (XML file format)
  440.          */
  441.         private void parseMetaDataEntry() {

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

  445.             try {
  446.                 switch (keyValue.getKeyword()) {
  447.                     case TIME_SYSTEM:
  448.                         // Read the time system and ensure that it is supported by Orekit
  449.                         if (!CcsdsTimeScale.contains(keyValue.getValue())) {
  450.                             throw new OrekitException(OrekitMessages.CCSDS_TIME_SYSTEM_NOT_IMPLEMENTED,
  451.                                                       keyValue.getValue());
  452.                         }
  453.                         final CcsdsTimeScale timeSystem =
  454.                                         CcsdsTimeScale.valueOf(keyValue.getValue());
  455.                         metaData.setTimeSystem(timeSystem);

  457.                         // Convert start/stop time to AbsoluteDate if they have been read already
  458.                         if (metaData.getStartTimeString() != null) {
  459.                             metaData.setStartTime(parseDate(metaData.getStartTimeString(), timeSystem));
  460.                         }
  461.                         if (metaData.getStopTimeString() != null) {
  462.                             metaData.setStopTime(parseDate(metaData.getStopTimeString(), timeSystem));
  463.                         }
  464.                         break;

  466.                     case START_TIME:
  467.                         // Set the start time as a String first
  468.                         metaData.setStartTimeString(keyValue.getValue());

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

  476.                     case STOP_TIME:
  477.                         // Set the stop time as a String first
  478.                         metaData.setStopTimeString(keyValue.getValue());

  480.                         // If time system has already been defined, convert the start time to an AbsoluteDate
  481.                         if (metaData.getTimeSystem() != null) {
  482.                             metaData.setStopTime(parseDate(keyValue.getValue(), metaData.getTimeSystem()));
  483.                         }
  484.                         break;

  486.                     case PARTICIPANT_1: case PARTICIPANT_2: case PARTICIPANT_3:
  487.                     case PARTICIPANT_4: case PARTICIPANT_5:
  488.                         // Get the participant number
  489.                         String key = keyValue.getKey();
  490.                         int participantNumber = Integer.parseInt(key.substring(key.length() - 1));

  492.                         // Add the tuple to the map
  493.                         metaData.addParticipant(participantNumber, keyValue.getValue());
  494.                         break;

  496.                     case MODE:
  497.                         metaData.setMode(keyValue.getValue());
  498.                         break;

  500.                     case PATH:
  501.                         metaData.setPath(keyValue.getValue());
  502.                         break;

  504.                     case PATH_1:
  505.                         metaData.setPath1(keyValue.getValue());
  506.                         break;

  508.                     case PATH_2:
  509.                         metaData.setPath2(keyValue.getValue());
  510.                         break;

  512.                     case TRANSMIT_BAND:
  513.                         metaData.setTransmitBand(keyValue.getValue());
  514.                         break;

  516.                     case RECEIVE_BAND:
  517.                         metaData.setReceiveBand(keyValue.getValue());
  518.                         break;

  520.                     case TURNAROUND_NUMERATOR:
  521.                         metaData.setTurnaroundNumerator(keyValue.getIntegerValue());
  522.                         break;

  524.                     case TURNAROUND_DENOMINATOR:
  525.                         metaData.setTurnaroundDenominator(keyValue.getIntegerValue());
  526.                         break;

  528.                     case TIMETAG_REF:
  529.                         metaData.setTimetagRef(keyValue.getValue());
  530.                         break;

  532.                     case INTEGRATION_INTERVAL:
  533.                         metaData.setIntegrationInterval(keyValue.getDoubleValue());
  534.                         break;

  536.                     case INTEGRATION_REF:
  537.                         metaData.setIntegrationRef(keyValue.getValue());
  538.                         break;

  540.                     case FREQ_OFFSET:
  541.                         metaData.setFreqOffset(keyValue.getDoubleValue());
  542.                         break;

  544.                     case RANGE_MODE:
  545.                         metaData.setRangeMode(keyValue.getValue());
  546.                         break;

  548.                     case RANGE_MODULUS:
  549.                         metaData.setRangeModulus(keyValue.getDoubleValue());
  550.                         break;

  552.                     case RANGE_UNITS:
  553.                         metaData.setRangeUnits(keyValue.getValue());
  554.                         break;

  556.                     case ANGLE_TYPE:
  557.                         metaData.setAngleType(keyValue.getValue());
  558.                         break;

  560.                     case REFERENCE_FRAME:
  561.                         metaData.setReferenceFrameString(keyValue.getValue());
  562.                         metaData.setReferenceFrame(parseCCSDSFrame(keyValue.getValue())
  563.                                 .getFrame(this.conventions, this.simpleEOP, dataContext));
  564.                         break;

  566.                     case TRANSMIT_DELAY_1: case TRANSMIT_DELAY_2: case TRANSMIT_DELAY_3:
  567.                     case TRANSMIT_DELAY_4: case TRANSMIT_DELAY_5:
  568.                         // Get the participant number
  569.                         key = keyValue.getKey();
  570.                         participantNumber = Integer.parseInt(key.substring(key.length() - 1));

  572.                         // Add the tuple to the map
  573.                         metaData.addTransmitDelay(participantNumber, keyValue.getDoubleValue());
  574.                         break;

  576.                     case RECEIVE_DELAY_1: case RECEIVE_DELAY_2: case RECEIVE_DELAY_3:
  577.                     case RECEIVE_DELAY_4: case RECEIVE_DELAY_5:
  578.                         // Get the participant number
  579.                         key = keyValue.getKey();
  580.                         participantNumber = Integer.parseInt(key.substring(key.length() - 1));

  582.                         // Add the tuple to the map
  583.                         metaData.addReceiveDelay(participantNumber, keyValue.getDoubleValue());
  584.                         break;

  586.                     case DATA_QUALITY:
  587.                         metaData.setDataQuality(keyValue.getValue());
  588.                         break;

  590.                     case CORRECTION_ANGLE_1:
  591.                         metaData.setCorrectionAngle1(keyValue.getDoubleValue());
  592.                         break;

  594.                     case CORRECTION_ANGLE_2:
  595.                         metaData.setCorrectionAngle2(keyValue.getDoubleValue());
  596.                         break;

  598.                     case CORRECTION_DOPPLER:
  599.                         metaData.setCorrectionDoppler(keyValue.getDoubleValue());
  600.                         break;

  602.                     case CORRECTION_RANGE:
  603.                         metaData.setCorrectionRange(keyValue.getDoubleValue());
  604.                         break;

  606.                     case CORRECTION_RECEIVE:
  607.                         metaData.setCorrectionReceive(keyValue.getDoubleValue());
  608.                         break;

  610.                     case CORRECTION_TRANSMIT:
  611.                         metaData.setCorrectionTransmit(keyValue.getDoubleValue());
  612.                         break;

  614.                     case CORRECTIONS_APPLIED:
  615.                         metaData.setCorrectionsApplied(keyValue.getValue());
  616.                         break;

  618.                     default:
  619.                         throw new OrekitException(OrekitMessages.CCSDS_UNEXPECTED_KEYWORD, lineNumber, fileName, line);
  620.                 }
  621.             } catch (NumberFormatException nfe) {
  622.                 throw new OrekitException(OrekitMessages.UNABLE_TO_PARSE_LINE_IN_FILE,
  623.                                           lineNumber, fileName, line);
  624.             }
  625.         }

  627.         /** Parse a CCSDS frame.
  628.          * @param frameName name of the frame, as the value of a CCSDS key=value line
  629.          * @return CCSDS frame corresponding to the name
  630.          */
  631.         private CCSDSFrame parseCCSDSFrame(final String frameName) {
  632.             return CCSDSFrame.valueOf(DASH.matcher(frameName).replaceAll(""));
  633.         }

  635.         /** Parse a date.
  636.          * @param date date to parse, as the value of a CCSDS key=value line
  637.          * @param timeSystem time system to use
  638.          * @return parsed date
  639.          */
  640.         private AbsoluteDate parseDate(final String date, final CcsdsTimeScale timeSystem) {
  641.             return timeSystem.parseDate(date, conventions, missionReferenceDate,
  642.                     dataContext.getTimeScales());
  643.         }
  644.     }

  646.     /** Handler for parsing KEYVALUE file formats. */
  647.     private static class KeyValueHandler {

  649.         /** ParseInfo object. */
  650.         private ParseInfo parseInfo;

  652.         /** Simple constructor.
  653.          * @param parseInfo ParseInfo object
  654.          */
  655.         KeyValueHandler(final ParseInfo parseInfo) {
  656.             this.parseInfo       = parseInfo;
  657.         }

  659.         /**
  660.          * Parse an observation data line and add its content to the Observations Block
  661.          * block.
  662.          *
  663.          */
  664.         private void parseObservationsDataLine() {

  666.             // Parse an observation line
  667.             // An observation line should consist in the string "keyword = epoch value"
  668.             // parseInfo.keyValue.getValue() should return the string "epoch value"
  669.             final String[] fields = SEPARATOR.split(parseInfo.keyValue.getValue());

  671.             // Check that there are 2 fields in the value of the key
  672.             if (fields.length != 2) {
  673.                 throw new OrekitException(OrekitMessages.CCSDS_TDM_INCONSISTENT_DATA_LINE,
  674.                                           parseInfo.lineNumber, parseInfo.fileName, parseInfo.line);
  675.             }

  677.             // Convert the date to an AbsoluteDate object (OrekitException if it fails)
  678.             final AbsoluteDate epoch = parseInfo.parseDate(fields[0], parseInfo.currentObservationsBlock.getMetaData().getTimeSystem());
  679.             final double measurement;
  680.             try {
  681.                 // Convert the value to double (NumberFormatException if it fails)
  682.                 measurement = Double.parseDouble(fields[1]);
  683.             } catch (NumberFormatException nfe) {
  684.                 throw new OrekitException(OrekitMessages.UNABLE_TO_PARSE_LINE_IN_FILE,
  685.                                           parseInfo.lineNumber, parseInfo.fileName, parseInfo.line);
  686.             }

  688.             // Adds the observation to current observation block
  689.             parseInfo.currentObservationsBlock.addObservation(parseInfo.keyValue.getKeyword().name(),
  690.                                                        epoch,
  691.                                                        measurement);
  692.         }

  694.         /** Parse a CCSDS Tracking Data Message with KEYVALUE format.
  695.          * @param stream stream containing message
  696.          * @param fileName name of the file containing the message (for error messages)
  697.          * @return parsed file content in a TDMFile object
  698.          */
  699.         public TDMFile parse(final InputStream stream, final String fileName) {
  700.             try (BufferedReader reader = new BufferedReader(new InputStreamReader(stream, StandardCharsets.UTF_8))) {
  701.                 try {
  702.                     // Initialize internal TDMFile
  703.                     final TDMFile tdmFile = parseInfo.tdmFile;

  705.                     // Read the file
  706.                     for (String line = reader.readLine(); line != null; line = reader.readLine()) {
  707.                         ++parseInfo.lineNumber;
  708.                         if (line.trim().length() == 0) {
  709.                             continue;
  710.                         }
  711.                         parseInfo.line = line;
  712.                         parseInfo.keyValue = new KeyValue(parseInfo.line, parseInfo.lineNumber, parseInfo.fileName);
  713.                         if (parseInfo.keyValue.getKeyword() == null) {
  714.                             throw new OrekitException(OrekitMessages.CCSDS_UNEXPECTED_KEYWORD, parseInfo.lineNumber, parseInfo.fileName, parseInfo.line);
  715.                         }
  716.                         switch (parseInfo.keyValue.getKeyword()) {

  718.                             // Header entries
  719.                             case CCSDS_TDM_VERS:
  720.                                 // Set CCSDS TDM version
  721.                                 tdmFile.setFormatVersion(parseInfo.keyValue.getDoubleValue());
  722.                                 break;

  724.                             case CREATION_DATE:
  725.                                 // Save current comment in header
  726.                                 tdmFile.setHeaderComment(parseInfo.commentTmp);
  727.                                 parseInfo.commentTmp.clear();
  728.                                 // Set creation date
  729.                                 tdmFile.setCreationDate(new AbsoluteDate(
  730.                                         parseInfo.keyValue.getValue(),
  731.                                         parseInfo.dataContext.getTimeScales().getUTC()));
  732.                                 break;

  734.                             case ORIGINATOR:
  735.                                 // Set originator
  736.                                 tdmFile.setOriginator(parseInfo.keyValue.getValue());
  737.                                 break;

  739.                                 // Comments
  740.                             case COMMENT:
  741.                                 parseInfo.commentTmp.add(parseInfo.keyValue.getValue());
  742.                                 break;

  744.                                 // Start/Strop keywords
  745.                             case META_START:
  746.                                 // Add an observation block and set the last observation block to the current
  747.                                 tdmFile.addObservationsBlock();
  748.                                 parseInfo.currentObservationsBlock = tdmFile.getObservationsBlocks().get(tdmFile.getObservationsBlocks().size() - 1);
  749.                                 // Indicate the start of meta-data parsing for this block
  750.                                 parseInfo.parsingMetaData = true;
  751.                                 break;

  753.                             case META_STOP:
  754.                                 // Save current comment in current meta-data comment
  755.                                 parseInfo.currentObservationsBlock.getMetaData().setComment(parseInfo.commentTmp);
  756.                                 parseInfo.commentTmp.clear();
  757.                                 // Indicate the end of meta-data parsing for this block
  758.                                 parseInfo.parsingMetaData = false;
  759.                                 break;

  761.                             case DATA_START:
  762.                                 // Indicate the start of data parsing for this block
  763.                                 parseInfo.parsingData = true;
  764.                                 break;

  766.                             case DATA_STOP:
  767.                                 // Save current comment in current Observation Block comment
  768.                                 parseInfo.currentObservationsBlock.setObservationsComment(parseInfo.commentTmp);
  769.                                 parseInfo.commentTmp.clear();
  770.                                 // Indicate the end of data parsing for this block
  771.                                 parseInfo.parsingData = false;
  772.                                 break;

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

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

  807.         /** ParseInfo object. */
  808.         private ParseInfo parseInfo;

  810.         /** Locator used to get current line number. */
  811.         private Locator locator;

  813.         /** Current keyword being read. */
  814.         private Keyword currentKeyword;

  816.         /** Current observation keyword being read. */
  817.         private Keyword currentObservationKeyword;

  819.         /** Current observation epoch being read. */
  820.         private AbsoluteDate currentObservationEpoch;

  822.         /** Current observation measurement being read. */
  823.         private double currentObservationMeasurement;

  825.         /** Simple constructor.
  826.          * @param parseInfo ParseInfo object
  827.          */
  828.         XMLHandler(final ParseInfo parseInfo) {
  829.             this.parseInfo      = parseInfo;
  830.             this.locator        = null;
  831.             this.currentKeyword = null;
  832.             this.currentObservationKeyword      = null;
  833.             this.currentObservationEpoch        = null;
  834.             this.currentObservationMeasurement  = Double.NaN;
  835.         }

  837.         @Override
  838.         public void setDocumentLocator(final Locator documentLocator) {
  839.             this.locator = documentLocator;
  840.         }

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

  867.                     // Scan the keyword
  868.                     switch (currentKeyword) {

  870.                         case CREATION_DATE:
  871.                             // Set creation date
  872.                             parseInfo.tdmFile.setCreationDate(new AbsoluteDate(
  873.                                     parseInfo.keyValue.getValue(),
  874.                                     parseInfo.dataContext.getTimeScales().getUTC()));
  875.                             break;

  877.                         case ORIGINATOR:
  878.                             // Set originator
  879.                             parseInfo.tdmFile.setOriginator(parseInfo.keyValue.getValue());
  880.                             break;

  882.                         case COMMENT:
  883.                             // Comments
  884.                             parseInfo.commentTmp.add(parseInfo.keyValue.getValue());
  885.                             break;

  887.                         case tdm: case header: case body: case segment:
  888.                         case metadata: case data:case observation:
  889.                             // Do nothing for this tags
  890.                             break;

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

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

  947.                     case observation:
  948.                         // Re-initialize the stored observation's attributes
  949.                         this.currentObservationKeyword     = null;
  950.                         this.currentObservationEpoch       = null;
  951.                         this.currentObservationMeasurement = Double.NaN;
  952.                         break;

  954.                     case segment:
  955.                         // Add an observation block and set the last observation block to the current
  956.                         final TDMFile tdmFile = parseInfo.tdmFile;
  957.                         tdmFile.addObservationsBlock();
  958.                         parseInfo.currentObservationsBlock = tdmFile.getObservationsBlocks().get(tdmFile.getObservationsBlocks().size() - 1);
  959.                         break;

  961.                     case metadata:
  962.                         // Indicate the start of meta-data parsing for this block
  963.                         parseInfo.parsingMetaData = true;
  964.                         break;

  966.                     case data:
  967.                         // Indicate the start of data parsing for this block
  968.                         parseInfo.parsingData = true;
  969.                         break;

  971.                     default:
  972.                         // Ignore the element.
  973.                         break;
  974.                 }
  975.             }
  976.             catch (IllegalArgumentException | OrekitException e)
  977.             {
  978.                 throw new SAXException(e);
  979.             }
  980.         }

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

  1012.                     case header:
  1013.                         // Save header comment
  1014.                         parseInfo.tdmFile.setHeaderComment(parseInfo.commentTmp);
  1015.                         parseInfo.commentTmp.clear();
  1016.                         break;

  1018.                     case observation:
  1019.                         // Check that stored observation's attributes were all found
  1020.                         if (currentObservationKeyword == null         ||
  1021.                             currentObservationEpoch == null           ||
  1022.                             Double.isNaN(currentObservationMeasurement)) {
  1023.                             throw new OrekitException(OrekitMessages.CCSDS_TDM_XML_INCONSISTENT_DATA_BLOCK,
  1024.                                                       locator.getLineNumber(),
  1025.                                                       parseInfo.fileName);
  1026.                         } else {
  1027.                             // Add current observation
  1028.                             parseInfo.currentObservationsBlock.addObservation(currentObservationKeyword.name(),
  1029.                                                                               currentObservationEpoch,
  1030.                                                                               currentObservationMeasurement);
  1031.                         }
  1032.                         break;

  1034.                     case segment:
  1035.                         // Do nothing
  1036.                         break;

  1038.                     case metadata:
  1039.                         // Save current comment in current meta-data comment
  1040.                         parseInfo.currentObservationsBlock.getMetaData().setComment(parseInfo.commentTmp);
  1041.                         parseInfo.commentTmp.clear();
  1042.                         // Indicate the end of meta-data parsing for this block
  1043.                         parseInfo.parsingMetaData = false;
  1044.                         break;

  1046.                     case data:
  1047.                         // Save current comment in current Observation Block comment
  1048.                         parseInfo.currentObservationsBlock.setObservationsComment(parseInfo.commentTmp);
  1049.                         parseInfo.commentTmp.clear();
  1050.                         // Indicate the end of data parsing for this block
  1051.                         parseInfo.parsingData = false;
  1052.                         break;

  1054.                     default:
  1055.                         // Ignore the element.
  1056.                 }
  1057.             }
  1058.             catch (IllegalArgumentException | OrekitException e)
  1059.             {
  1060.                 throw new SAXException(e);
  1061.             }
  1062.         }

  1064.         @Override
  1065.         public InputSource resolveEntity(final String publicId, final String systemId) {
  1066.             // disable external entities
  1067.             return new InputSource();
  1068.         }

  1070.         /** Parse a line in an observation data block.
  1071.          */
  1072.         private void parseObservationDataLine() {

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