CdmParser.java

  1. /* Copyright 2002-2022 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.ndm.cdm;

  19. import java.util.ArrayList;
  20. import java.util.List;

  22. import org.orekit.data.DataContext;
  23. import org.orekit.files.ccsds.definitions.TimeSystem;
  24. import org.orekit.files.ccsds.ndm.ParsedUnitsBehavior;
  25. import org.orekit.files.ccsds.ndm.odm.UserDefined;
  26. import org.orekit.files.ccsds.section.CommentsContainer;
  27. import org.orekit.files.ccsds.section.KvnStructureProcessingState;
  28. import org.orekit.files.ccsds.section.MetadataKey;
  29. import org.orekit.files.ccsds.section.XmlStructureProcessingState;
  30. import org.orekit.files.ccsds.utils.ContextBinding;
  31. import org.orekit.files.ccsds.utils.FileFormat;
  32. import org.orekit.files.ccsds.utils.lexical.ParseToken;
  33. import org.orekit.files.ccsds.utils.lexical.TokenType;
  34. import org.orekit.files.ccsds.utils.parsing.AbstractConstituentParser;
  35. import org.orekit.files.ccsds.utils.parsing.ProcessingState;
  36. import org.orekit.utils.IERSConventions;

  38. /**
  39.  * Base class for Conjunction Data Message parsers.
  40.  * <p>
  41.  * Note than starting with Orekit 11.0, CCSDS message parsers are
  42.  * mutable objects that gather the data being parsed, until the
  43.  * message is complete and the {@link #parseMessage(org.orekit.data.DataSource)
  44.  * parseMessage} method has returned. This implies that parsers
  45.  * should <em>not</em> be used in a multi-thread context. The recommended
  46.  * way to use parsers is to either dedicate one parser for each message
  47.  * and drop it afterwards, or to use a single-thread loop.
  48.  * </p>
  49.  * @author Melina Vanel
  50.  * @since 11.2
  51.  */
  52. public class CdmParser extends AbstractConstituentParser<Cdm, CdmParser> {

  54.     /** Comment key. */
  55.     private static String COMMENT = "COMMENT";

  57.     /** XML relative metadata key. */
  58.     private static String RELATIVEMETADATA = "relativeMetadataData";

  60.     /** XML metadata key. */
  61.     private static String METADATA = "metadata";

  63.     /** File header. */
  64.     private CdmHeader header;

  66.     /** File segments. */
  67.     private List<CdmSegment> segments;

  69.     /** CDM metadata being read. */
  70.     private CdmMetadata metadata;

  72.     /** CDM relative metadata being read. */
  73.     private CdmRelativeMetadata relativeMetadata;

  75.     /** Context binding valid for current metadata. */
  76.     private ContextBinding context;

  78.     /** CDM general data comments block being read. */
  79.     private CommentsContainer commentsBlock;

  81.     /** CDM OD parameters logical block being read. */
  82.     private ODParameters odParameters;

  84.     /** CDM additional parameters logical block being read. */
  85.     private AdditionalParameters addParameters;

  87.     /** CDM state vector logical block being read. */
  88.     private StateVector stateVector;

  90.     /** CDM covariance matrix logical block being read. */
  91.     private RTNCovariance covMatrix;

  93.     /** CDM XYZ covariance matrix logical block being read. */
  94.     private XYZCovariance xyzCovMatrix;

  96.     /** CDM Sigma/Eigenvectors covariance logical block being read. */
  97.     private SigmaEigenvectorsCovariance sig3eigvec3;

  99.     /** CDM additional covariance metadata logical block being read. */
  100.     private AdditionalCovarianceMetadata additionalCovMetadata;

  102.     /** Processor for global message structure. */
  103.     private ProcessingState structureProcessor;

  105.     /** Flag to only compute once relative metadata. */
  106.     private boolean doRelativeMetadata;

  108.     /** Flag to indicate that data block parsing is finished. */
  109.     private boolean isDatafinished;

  111.     /** CDM user defined logical block being read. */
  112.     private UserDefined userDefinedBlock;


  115.     /** Complete constructor.
  116.      * <p>
  117.      * Calling this constructor directly is not recommended. Users should rather use
  118.      * {@link org.orekit.files.ccsds.ndm.ParserBuilder#buildCdmParser()
  119.      * parserBuilder.buildCdmParser()}.
  120.      * </p>
  121.      * @param conventions IERS Conventions
  122.      * @param simpleEOP if true, tidal effects are ignored when interpolating EOP
  123.      * @param dataContext used to retrieve frames, time scales, etc.
  124.      * @param parsedUnitsBehavior behavior to adopt for handling parsed units
  125.      */
  126.     public CdmParser(final IERSConventions conventions, final boolean simpleEOP, final DataContext dataContext,
  127.                      final ParsedUnitsBehavior parsedUnitsBehavior) {
  128.         super(Cdm.ROOT, Cdm.FORMAT_VERSION_KEY, conventions, simpleEOP, dataContext, parsedUnitsBehavior);
  129.         this.doRelativeMetadata = true;
  130.         this.isDatafinished = false;
  131.     }

  133.     /** {@inheritDoc} */
  134.     @Override
  135.     public CdmHeader getHeader() {
  136.         return header;
  137.     }

  139.     /** {@inheritDoc} */
  140.     @Override
  141.     public void reset(final FileFormat fileFormat) {
  142.         header                    = new CdmHeader(1.0);
  143.         segments                  = new ArrayList<>();
  144.         metadata                  = null;
  145.         relativeMetadata          = null;
  146.         context                   = null;
  147.         odParameters              = null;
  148.         addParameters             = null;
  149.         stateVector               = null;
  150.         covMatrix                 = null;
  151.         xyzCovMatrix              = null;
  152.         sig3eigvec3               = null;
  153.         additionalCovMetadata     = null;
  154.         userDefinedBlock          = null;
  155.         commentsBlock             = null;
  156.         if (fileFormat == FileFormat.XML) {
  157.             structureProcessor = new XmlStructureProcessingState(Cdm.ROOT, this);
  158.             reset(fileFormat, structureProcessor);
  159.         } else {
  160.             structureProcessor = new KvnStructureProcessingState(this);
  161.             reset(fileFormat, new CdmHeaderProcessingState(this));
  162.         }
  163.     }

  165.     /** {@inheritDoc} */
  166.     @Override
  167.     public boolean prepareHeader() {
  168.         anticipateNext(new CdmHeaderProcessingState(this));
  169.         return true;
  170.     }

  172.     /** {@inheritDoc} */
  173.     @Override
  174.     public boolean inHeader() {
  175.         anticipateNext(getFileFormat() == FileFormat.XML ? structureProcessor : this::processMetadataToken);
  176.         return true;
  177.     }

  179.     /** {@inheritDoc} */
  180.     @Override
  181.     public boolean finalizeHeader() {
  182.         anticipateNext(getFileFormat() == FileFormat.XML ? this::processXmlSubStructureToken : structureProcessor);
  183.         header.validate(header.getFormatVersion());
  184.         return true;
  185.     }

  187.     /** {@inheritDoc} */
  188.     @Override
  189.     public boolean prepareMetadata() {
  190.         if (metadata != null) {
  191.             return false;
  192.         }
  193.         if (doRelativeMetadata) {
  194.             // if parser is just after header it is time to create / read relative metadata,
  195.             // their are only initialized once and then shared between metadata for object 1 and 2
  196.             relativeMetadata = new CdmRelativeMetadata();
  197.             relativeMetadata.setTimeSystem(TimeSystem.UTC);
  198.         }
  199.         metadata  = new CdmMetadata();
  200.         metadata.setRelativeMetadata(relativeMetadata);

  202.         // As no time system is defined in CDM because all dates are given in UTC,
  203.         // time system is set here to UTC, we use relative metadata and not metadata
  204.         // because setting time system on metadata implies refusingfurthercomments
  205.         // witch would be a problem as metadata comments have not been read yet.
  206.         context   = new ContextBinding(this::getConventions, this::isSimpleEOP,
  207.                                        this::getDataContext, this::getParsedUnitsBehavior,
  208.                                        () -> null, relativeMetadata::getTimeSystem,
  209.                                        () -> 0.0, () -> 1.0);
  210.         anticipateNext(this::processMetadataToken);
  211.         return true;
  212.     }

  214.     /** {@inheritDoc} */
  215.     @Override
  216.     public boolean inMetadata() {
  217.         anticipateNext(getFileFormat() == FileFormat.XML ? this::processXmlSubStructureToken : this::processGeneralCommentToken);
  218.         return true;
  219.     }

  221.     /** {@inheritDoc} */
  222.     @Override
  223.     public boolean finalizeMetadata() {
  224.         metadata.validate(header.getFormatVersion());
  225.         relativeMetadata.validate();
  226.         anticipateNext(structureProcessor);
  227.         return true;
  228.     }

  230.     /** {@inheritDoc} */
  231.     @Override
  232.     public boolean prepareData() {
  233.         // stateVector and RTNCovariance blocks are 2 mandatory data blocks
  234.         stateVector = new StateVector();
  235.         covMatrix = new RTNCovariance();

  237.         // initialize comments block for general data comments
  238.         commentsBlock = new CommentsContainer();
  239.         anticipateNext(getFileFormat() == FileFormat.XML ? this::processXmlSubStructureToken : this::processGeneralCommentToken);
  240.         return true;
  241.     }

  243.     /** {@inheritDoc} */
  244.     @Override
  245.     public boolean inData() {
  246.         return true;
  247.     }

  249.     /** {@inheritDoc} */
  250.     @Override
  251.     public boolean finalizeData() {
  252.         // call at the and of data block for object 1 or 2
  253.         if (metadata != null) {

  255.             CdmData data = new CdmData(commentsBlock, odParameters, addParameters,
  256.                                              stateVector, covMatrix, additionalCovMetadata);

  258.             if (metadata.getAltCovType() != null && metadata.getAltCovType() == AltCovarianceType.XYZ) {
  259.                 data = new CdmData(commentsBlock, odParameters, addParameters,
  260.                                              stateVector, covMatrix, xyzCovMatrix, additionalCovMetadata);
  261.             } else if (metadata.getAltCovType() != null && metadata.getAltCovType() == AltCovarianceType.CSIG3EIGVEC3) {
  262.                 data = new CdmData(commentsBlock, odParameters, addParameters,
  263.                                              stateVector, covMatrix, sig3eigvec3, additionalCovMetadata);
  264.             }

  266.             data.validate(header.getFormatVersion());
  267.             segments.add(new CdmSegment(metadata, data));

  269.             // Add the user defined block to both Objects data sections
  270.             if (userDefinedBlock != null && !userDefinedBlock.getParameters().isEmpty()) {
  271.                 for (int i = 0; i < segments.size(); i++) {
  272.                     segments.get(i).getData().setUserDefinedBlock(userDefinedBlock);
  273.                 }
  274.             }
  275.         }
  276.         metadata                  = null;
  277.         context                   = null;
  278.         odParameters              = null;
  279.         addParameters             = null;
  280.         stateVector               = null;
  281.         covMatrix                 = null;
  282.         xyzCovMatrix              = null;
  283.         sig3eigvec3               = null;
  284.         additionalCovMetadata     = null;
  285.         userDefinedBlock          = null;
  286.         commentsBlock             = null;
  287.         return true;
  288.     }

  290.     /** {@inheritDoc} */
  291.     @Override
  292.     public Cdm build() {
  293.         // CDM KVN file lack a DATA_STOP keyword, hence we can't call finalizeData()
  294.         // automatically before the end of the file
  295.         finalizeData();
  296.         if (userDefinedBlock != null && userDefinedBlock.getParameters().isEmpty()) {
  297.             userDefinedBlock = null;
  298.         }
  299.         final Cdm file = new Cdm(header, segments, getConventions(), getDataContext());
  300.         return file;
  301.     }

  303.     /** Add a general comment.
  304.      * @param comment comment to add
  305.      * @return always return true
  306.      */
  307.     boolean addGeneralComment(final String comment) {
  308.         return commentsBlock.addComment(comment);

  310.     }

  312.     /** Manage relative metadata section.
  313.      * @param starting if true, parser is entering the section
  314.      * otherwise it is leaving the section
  315.      * @return always return true
  316.      */
  317.     boolean manageRelativeMetadataSection(final boolean starting) {
  318.         anticipateNext(starting ? this::processMetadataToken : structureProcessor);
  319.         return true;
  320.     }

  322.     /** Manage relative metadata state vector section.
  323.      * @param starting if true, parser is entering the section
  324.      * otherwise it is leaving the section
  325.      * @return always return true
  326.      */
  327.     boolean manageRelativeStateVectorSection(final boolean starting) {
  328.         anticipateNext(this::processMetadataToken);
  329.         return true;
  330.     }

  332.     /** Manage OD parameters section.
  333.      * @param starting if true, parser is entering the section
  334.      * otherwise it is leaving the section
  335.      * @return always return true
  336.      */
  337.     boolean manageODParametersSection(final boolean starting) {
  338.         commentsBlock.refuseFurtherComments();
  339.         anticipateNext(starting ? this::processODParamToken : structureProcessor);
  340.         return true;
  341.     }

  343.     /** Manage additional parameters section.
  344.      * @param starting if true, parser is entering the section
  345.      * otherwise it is leaving the section
  346.      * @return always return true
  347.      */
  348.     boolean manageAdditionalParametersSection(final boolean starting) {
  349.         commentsBlock.refuseFurtherComments();
  350.         anticipateNext(starting ? this::processAdditionalParametersToken : structureProcessor);
  351.         return true;
  352.     }

  354.     /** Manage state vector section.
  355.      * @param starting if true, parser is entering the section
  356.      * otherwise it is leaving the section
  357.      * @return always return true
  358.      */
  359.     boolean manageStateVectorSection(final boolean starting) {
  360.         commentsBlock.refuseFurtherComments();
  361.         anticipateNext(starting ? this::processStateVectorToken : structureProcessor);
  362.         return true;
  363.     }

  365.     /** Manage general covariance section in XML file.
  366.      * @param starting if true, parser is entering the section
  367.      * otherwise it is leaving the section
  368.      * @return always return true
  369.      */
  370.     boolean manageXmlGeneralCovarianceSection(final boolean starting) {
  371.         commentsBlock.refuseFurtherComments();

  373.         if (starting) {
  374.             if (metadata.getAltCovType() == null) {
  375.                 anticipateNext(this::processCovMatrixToken);
  376.             } else {
  377.                 if (Double.isNaN(covMatrix.getCrr())) {
  378.                     // First, handle mandatory RTN covariance section
  379.                     anticipateNext(this::processCovMatrixToken);
  380.                 } else if ( metadata.getAltCovType() == AltCovarianceType.XYZ && xyzCovMatrix == null ||
  381.                                 metadata.getAltCovType() == AltCovarianceType.CSIG3EIGVEC3 && sig3eigvec3 == null ) {
  382.                     // Second, add the alternate covariance if provided
  383.                     anticipateNext(this::processAltCovarianceToken);
  384.                 } else if (additionalCovMetadata == null) {
  385.                     // Third, process the additional covariance metadata
  386.                     anticipateNext(this::processAdditionalCovMetadataToken);
  387.                 }
  388.             }
  389.         } else {
  390.             anticipateNext(structureProcessor);
  391.         }

  393.         return true;
  394.     }

  396.     /** Manage user-defined parameters section.
  397.      * @param starting if true, parser is entering the section
  398.      * otherwise it is leaving the section
  399.      * @return always return true
  400.      */
  401.     boolean manageUserDefinedParametersSection(final boolean starting) {
  402.         commentsBlock.refuseFurtherComments();
  403.         if (starting) {
  404.             if (userDefinedBlock == null) {
  405.                 // this is the first (and unique) user-defined parameters block, we need to allocate the container
  406.                 userDefinedBlock = new UserDefined();
  407.             }
  408.             anticipateNext(this::processUserDefinedToken);
  409.         } else {
  410.             anticipateNext(structureProcessor);
  411.         }
  412.         return true;
  413.     }

  415.     /** Process one metadata token.
  416.      * @param token token to process
  417.      * @return true if token was processed, false otherwise
  418.      */
  419.     private boolean processMetadataToken(final ParseToken token) {
  420.         if (isDatafinished && getFileFormat() != FileFormat.XML) {
  421.             finalizeData();
  422.             isDatafinished = false;
  423.         }
  424.         if (metadata == null) {
  425.             // CDM KVN file lack a META_START keyword, hence we can't call prepareMetadata()
  426.             // automatically before the first metadata token arrives
  427.             prepareMetadata();
  428.         }
  429.         inMetadata();

  431.         // There can be a COMMENT key at the beginning of relative metadata, but as the relative
  432.         // metadata are processed in the same try and catch loop than metadata because Orekit is
  433.         // build to read metadata and then data (and not relative metadata), it would be problematic
  434.         // to make relative metadata extends comments container(because of the COMMENTS in the middle
  435.         // of relativemetadata and metadata section. Indeed, as said in {@link
  436.         // #CommentsContainer} COMMENT should only be at the beginning of sections but in this case
  437.         // there is a comment at the beginning corresponding to the relative metadata comment
  438.         // and 1 in the middle for object 1 metadata and one further for object 2 metadata. That
  439.         // is why this special syntax was used and initializes the relative metadata COMMENT once
  440.         // at the beginning as relative metadata is not a comment container
  441.         if (COMMENT.equals(token.getName()) && doRelativeMetadata ) {
  442.             if (token.getType() == TokenType.ENTRY) {
  443.                 relativeMetadata.addComment(token.getContentAsNormalizedString());
  444.                 return true;
  445.             }
  446.         }
  447.         doRelativeMetadata = false;

  449.         try {
  450.             return token.getName() != null &&
  451.                    CdmRelativeMetadataKey.valueOf(token.getName()).process(token, context, relativeMetadata);
  452.         } catch (IllegalArgumentException iaeM) {
  453.             try {
  454.                 return MetadataKey.valueOf(token.getName()).process(token, context, metadata);
  455.             } catch (IllegalArgumentException iaeD) {
  456.                 try {
  457.                     return CdmMetadataKey.valueOf(token.getName()).process(token, context, metadata);
  458.                 } catch (IllegalArgumentException iaeC) {
  459.                     // token has not been recognized
  460.                     return false;
  461.                 }
  462.             }
  463.         }
  464.     }

  466.     /** Process one XML data substructure token.
  467.      * @param token token to process
  468.      * @return true if token was processed, false otherwise
  469.      */
  470.     private boolean processXmlSubStructureToken(final ParseToken token) {

  472.         // As no relativemetadata token exists in the structure processor and as RelativeMetadata keys are
  473.         // processed in the same try and catch loop in processMetadatatoken as CdmMetadata keys, if the relativemetadata
  474.         // token is read it should be as if the token was equal to metadata to start to initialize relative metadata
  475.         // and metadata and to go in the processMetadataToken try and catch loop. The following relativemetadata
  476.         // stop should be ignored to stay in the processMetadataToken try and catch loop and the following metadata
  477.         // start also ignored to stay in the processMetadataToken try and catch loop. Then arrives the end of metadata
  478.         // so we call structure processor with metadata stop. This distinction of cases is useful for relativemetadata
  479.         // block followed by metadata block for object 1 and also useful to only close metadata block for object 2.
  480.         // The metadata start for object 2 is processed by structureProcessor
  481.         if (METADATA.equals(token.getName()) && TokenType.START.equals(token.getType()) ||
  482.             RELATIVEMETADATA.equals(token.getName()) && TokenType.STOP.equals(token.getType())) {
  483.             anticipateNext(this::processMetadataToken);
  484.             return true;

  486.         } else if (RELATIVEMETADATA.equals(token.getName()) && TokenType.START.equals(token.getType()) ||
  487.                    METADATA.equals(token.getName()) && TokenType.STOP.equals(token.getType())) {
  488.             final ParseToken replaceToken = new ParseToken(token.getType(), METADATA,
  489.                                       null, token.getUnits(), token.getLineNumber(), token.getFileName());

  491.             return structureProcessor.processToken(replaceToken);

  493.         } else {

  495.             // Relative metadata COMMENT and metadata COMMENT should not be read by XmlSubStructureKey that
  496.             // is why 2 cases are distinguished here : the COMMENT for relative metadata and the COMMENT
  497.             // for metadata.
  498.             if (commentsBlock == null && COMMENT.equals(token.getName())) {

  500.                 // COMMENT adding for Relative Metadata in XML
  501.                 if (doRelativeMetadata) {
  502.                     if (token.getType() == TokenType.ENTRY) {
  503.                         relativeMetadata.addComment(token.getContentAsNormalizedString());
  504.                         doRelativeMetadata = false;
  505.                         return true;

  507.                     } else {
  508.                         // if the token Type is still not ENTRY we return true as at the next step
  509.                         // it will be ENTRY ad we will be able to store the comment (similar treatment
  510.                         // as OD parameter or Additional parameter or State Vector ... COMMENT treatment.)
  511.                         return true;
  512.                     }
  513.                 }

  515.                 // COMMENT adding for Metadata in XML
  516.                 if (!doRelativeMetadata) {
  517.                     if (token.getType() == TokenType.ENTRY) {
  518.                         metadata.addComment(token.getContentAsNormalizedString());
  519.                         return true;

  521.                     } else {
  522.                         // same as above
  523.                         return true;
  524.                     }
  525.                 }
  526.             }

  528.             // to treat XmlSubStructureKey keys ( OD parameters, relative Metadata ...)
  529.             try {
  530.                 return token.getName() != null && !doRelativeMetadata &&
  531.                        XmlSubStructureKey.valueOf(token.getName()).process(token, this);
  532.             } catch (IllegalArgumentException iae) {
  533.                 // token has not been recognized
  534.                 return false;
  535.             }
  536.         }
  537.     }

  539.     /** Process one comment token.
  540.      * @param token token to process
  541.      * @return true if token was processed, false otherwise
  542.      */
  543.     private boolean processGeneralCommentToken(final ParseToken token) {
  544.         if (commentsBlock == null) {
  545.             // CDM KVN file lack a META_STOP keyword, hence we can't call finalizeMetadata()
  546.             // automatically before the first data token arrives
  547.             finalizeMetadata();
  548.             // CDM KVN file lack a DATA_START keyword, hence we can't call prepareData()
  549.             // automatically before the first data token arrives
  550.             prepareData();
  551.         }
  552.         anticipateNext(getFileFormat() == FileFormat.XML ? this::processXmlSubStructureToken : this::processODParamToken);
  553.         if (COMMENT.equals(token.getName()) && commentsBlock.acceptComments()) {
  554.             if (token.getType() == TokenType.ENTRY) {
  555.                 commentsBlock.addComment(token.getContentAsNormalizedString());
  556.             }
  557.             // in order to be able to differentiate general data comments and next block comment (OD parameters if not empty)
  558.             // only 1 line comment is allowed for general data comment.
  559.             commentsBlock.refuseFurtherComments();
  560.             return true;
  561.         } else {
  562.             return false;
  563.         }
  564.     }

  566.     /** Process one od parameter data token.
  567.      * @param token token to process
  568.      * @return true if token was processed, false otherwise
  569.      */
  570.     private boolean processODParamToken(final ParseToken token) {
  571.         if (odParameters == null) {
  572.             odParameters = new ODParameters();
  573.         }
  574.         anticipateNext(getFileFormat() == FileFormat.XML ? this::processXmlSubStructureToken : this::processAdditionalParametersToken);
  575.         try {
  576.             return token.getName() != null &&
  577.                    ODParametersKey.valueOf(token.getName()).process(token, context, odParameters);
  578.         } catch (IllegalArgumentException iae) {
  579.             // token has not been recognized
  580.             return false;
  581.         }
  582.     }

  584.     /** Process one additional parameter data token.
  585.      * @param token token to process
  586.      * @return true if token was processed, false otherwise
  587.      */
  588.     private boolean processAdditionalParametersToken(final ParseToken token) {
  589.         if (addParameters == null) {
  590.             addParameters = new AdditionalParameters();
  591.         }
  592.         if (moveCommentsIfEmpty(odParameters, addParameters)) {
  593.             // get rid of the empty logical block
  594.             odParameters = null;
  595.         }
  596.         anticipateNext(getFileFormat() == FileFormat.XML ? this::processXmlSubStructureToken : this::processStateVectorToken);
  597.         try {
  598.             return token.getName() != null &&
  599.                    AdditionalParametersKey.valueOf(token.getName()).process(token, context, addParameters);
  600.         } catch (IllegalArgumentException iae) {
  601.             // token has not been recognized
  602.             return false;
  603.         }
  604.     }

  606.     /** Process one state vector data token.
  607.      * @param token token to process
  608.      * @return true if token was processed, false otherwise
  609.      */
  610.     private boolean processStateVectorToken(final ParseToken token) {
  611.         if (moveCommentsIfEmpty(addParameters, stateVector)) {
  612.             // get rid of the empty logical block
  613.             addParameters = null;
  614.         }
  615.         anticipateNext(getFileFormat() == FileFormat.XML ? this::processXmlSubStructureToken : this::processCovMatrixToken);
  616.         try {
  617.             return token.getName() != null &&
  618.                    StateVectorKey.valueOf(token.getName()).process(token, context, stateVector);
  619.         } catch (IllegalArgumentException iae) {
  620.             // token has not been recognized
  621.             return false;
  622.         }
  623.     }

  625.     /** Process covariance matrix data token.
  626.      * @param token token to process
  627.      * @return true if token was processed, false otherwise
  628.      */
  629.     private boolean processCovMatrixToken(final ParseToken token) {

  631.         if (moveCommentsIfEmpty(stateVector, covMatrix)) {
  632.             // get rid of the empty logical block
  633.             stateVector = null;
  634.         }

  636.         if (metadata.getAltCovType() == null) {
  637.             anticipateNext(getFileFormat() == FileFormat.XML ? this::processXmlSubStructureToken : this::processMetadataToken);
  638.         } else {
  639.             anticipateNext(getFileFormat() == FileFormat.XML ? this::processXmlSubStructureToken : this::processAltCovarianceToken);
  640.         }

  642.         isDatafinished = true;
  643.         try {
  644.             return token.getName() != null &&
  645.                    RTNCovarianceKey.valueOf(token.getName()).process(token, context, covMatrix);
  646.         } catch (IllegalArgumentException iae) {
  647.             // token has not been recognized
  648.             return false;
  649.         }
  650.     }

  652.     /** Process alternate covariance data token.
  653.      * @param token token to process
  654.      * @return true if token was processed, false otherwise
  655.      */
  656.     private boolean processAltCovarianceToken(final ParseToken token) {

  658.         // Covariance is provided in XYZ
  659.         if (metadata.getAltCovType() == AltCovarianceType.XYZ && xyzCovMatrix == null) {
  660.             xyzCovMatrix = new XYZCovariance(true);

  662.             if (moveCommentsIfEmpty(covMatrix, xyzCovMatrix)) {
  663.                 // get rid of the empty logical block
  664.                 covMatrix = null;
  665.             }
  666.         }
  667.         // Covariance is provided in CSIG3EIGVEC3 format
  668.         if (metadata.getAltCovType() == AltCovarianceType.CSIG3EIGVEC3 && sig3eigvec3 == null) {
  669.             sig3eigvec3 = new SigmaEigenvectorsCovariance(true);

  671.             if (moveCommentsIfEmpty(covMatrix, sig3eigvec3)) {
  672.                 // get rid of the empty logical block
  673.                 covMatrix = null;
  674.             }
  675.         }


  678.         anticipateNext(getFileFormat() == FileFormat.XML ? this::processXmlSubStructureToken : this::processAdditionalCovMetadataToken);
  679.         try {

  681.             if (metadata.getAltCovType() != null && metadata.getAltCovType() == AltCovarianceType.XYZ) {

  683.                 return token.getName() != null &&
  684.                            XYZCovarianceKey.valueOf(token.getName()).process(token, context, xyzCovMatrix);

  686.             } else if (metadata.getAltCovType() != null && metadata.getAltCovType() == AltCovarianceType.CSIG3EIGVEC3) {

  688.                 return token.getName() != null &&
  689.                            SigmaEigenvectorsCovarianceKey.valueOf(token.getName()).process(token, context, sig3eigvec3);

  691.             } else {

  693.                 // token has not been recognized
  694.                 return false;

  696.             }

  698.         } catch (IllegalArgumentException iae) {
  699.             // token has not been recognized
  700.             return false;
  701.         }
  702.     }

  704.     /** Process additional covariance metadata token.
  705.      * @param token token to process
  706.      * @return true if token was processed, false otherwise
  707.      */
  708.     private boolean processAdditionalCovMetadataToken(final ParseToken token) {

  710.         // Additional covariance metadata
  711.         if ( additionalCovMetadata == null) {
  712.             additionalCovMetadata = new AdditionalCovarianceMetadata();
  713.         }

  715.         if (moveCommentsIfEmpty(xyzCovMatrix, additionalCovMetadata)) {
  716.             // get rid of the empty logical block
  717.             xyzCovMatrix = null;
  718.         } else if (moveCommentsIfEmpty(sig3eigvec3, additionalCovMetadata)) {
  719.             // get rid of the empty logical block
  720.             sig3eigvec3 = null;
  721.         }

  723.         anticipateNext(getFileFormat() == FileFormat.XML ? this::processXmlSubStructureToken : this::processUserDefinedToken);
  724.         try {
  725.             return token.getName() != null &&
  726.                            AdditionalCovarianceMetadataKey.valueOf(token.getName()).process(token, context, additionalCovMetadata);
  727.         } catch (IllegalArgumentException iae) {
  728.             // token has not been recognized
  729.             return false;
  730.         }
  731.     }

  733.     /** Process one user-defined parameter data token.
  734.      * @param token token to process
  735.      * @return true if token was processed, false otherwise
  736.      */
  737.     private boolean processUserDefinedToken(final ParseToken token) {

  739.         if (userDefinedBlock == null) {
  740.             userDefinedBlock = new UserDefined();
  741.         }

  743.         if (moveCommentsIfEmpty(additionalCovMetadata, userDefinedBlock)) {
  744.             // get rid of the empty logical block
  745.             additionalCovMetadata = null;
  746.         }

  748.         anticipateNext(getFileFormat() == FileFormat.XML ? this::processXmlSubStructureToken : this::processMetadataToken);

  750.         if (COMMENT.equals(token.getName())) {
  751.             return token.getType() == TokenType.ENTRY ? userDefinedBlock.addComment(token.getContentAsNormalizedString()) : true;
  752.         } else if (token.getName().startsWith(UserDefined.USER_DEFINED_PREFIX)) {
  753.             if (token.getType() == TokenType.ENTRY) {
  754.                 userDefinedBlock.addEntry(token.getName().substring(UserDefined.USER_DEFINED_PREFIX.length()),
  755.                                           token.getContentAsNormalizedString());
  756.             }
  757.             return true;
  758.         } else {
  759.             // the token was not processed
  760.             return false;
  761.         }
  762.     }


  765.     /** Move comments from one empty logical block to another logical block.
  766.      * @param origin origin block
  767.      * @param destination destination block
  768.      * @return true if origin block was empty
  769.      */
  770.     private boolean moveCommentsIfEmpty(final CommentsContainer origin, final CommentsContainer destination) {
  771.         if (origin != null && origin.acceptComments()) {
  772.             // origin block is empty, move the existing comments
  773.             for (final String comment : origin.getComments()) {
  774.                 destination.addComment(comment);
  775.             }
  776.             return true;
  777.         } else {
  778.             return false;
  779.         }
  780.     }

  782. }
Created with JaCoCo 0.8.8.202204050719