ParseToken.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.utils.lexical;

  19. import java.util.ArrayList;
  20. import java.util.Arrays;
  21. import java.util.List;
  22. import java.util.Locale;
  23. import java.util.regex.Pattern;
  24. import java.util.stream.Collectors;
  25. import java.util.stream.Stream;

  27. import org.hipparchus.geometry.euclidean.threed.Vector3D;
  28. import org.orekit.bodies.CelestialBodies;
  29. import org.orekit.bodies.CelestialBody;
  30. import org.orekit.errors.OrekitException;
  31. import org.orekit.errors.OrekitMessages;
  32. import org.orekit.files.ccsds.definitions.BodyFacade;
  33. import org.orekit.files.ccsds.definitions.CelestialBodyFrame;
  34. import org.orekit.files.ccsds.definitions.CenterName;
  35. import org.orekit.files.ccsds.definitions.FrameFacade;
  36. import org.orekit.files.ccsds.definitions.OrbitRelativeFrame;
  37. import org.orekit.files.ccsds.definitions.SpacecraftBodyFrame;
  38. import org.orekit.files.ccsds.definitions.TimeSystem;
  39. import org.orekit.files.ccsds.ndm.ParsedUnitsBehavior;
  40. import org.orekit.files.ccsds.ndm.cdm.Maneuvrable;
  41. import org.orekit.files.ccsds.utils.ContextBinding;
  42. import org.orekit.time.AbsoluteDate;
  43. import org.orekit.utils.units.Unit;

  45. /** Token occurring during CCSDS file parsing.
  46.  * <p>
  47.  * Parse tokens correspond to:
  48.  * <ul>
  49.  *   <li>bloc or entry start</li>
  50.  *   <li>entry content</li>
  51.  *   <li>bloc or entry end</li>
  52.  *   <li>raw lines</li>
  53.  * </ul>
  54.  * @see MessageParser
  55.  * @author Luc Maisonobe
  56.  * @since 11.0
  57.  */
  58. public class ParseToken {

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

  63.     /** Pattern for spaces. */
  64.     private static final Pattern SPACE = Pattern.compile("\\p{Space}+");

  66.     /** Pattern for splitting comma-separated lists. */
  67.     private static final Pattern SPLIT_AT_COMMAS = Pattern.compile("\\p{Space}*,\\p{Space}*");

  69.     /** Pattern for splitting comma-separated lists with no space in between. */
  70.     private static final Pattern SPLIT_AT_COMMAS_NO_SPACE = Pattern.compile(",");

  72.     /** Pattern for true boolean value. */
  73.     private static final Pattern BOOLEAN_TRUE = Pattern.compile("(?:yes)|(?:true)",
  74.                                                                 Pattern.CASE_INSENSITIVE | Pattern.UNICODE_CASE);

  76.     /** Pattern for false boolean value. */
  77.     private static final Pattern BOOLEAN_FALSE = Pattern.compile("(?:no)|(?:false)",
  78.                                                                  Pattern.CASE_INSENSITIVE | Pattern.UNICODE_CASE);

  80.     /** Type of the token. */
  81.     private TokenType type;

  83.     /** Name of the entry. */
  84.     private final String name;

  86.     /** Entry content. */
  87.     private final String content;

  89.     /** Units of the entry. */
  90.     private final Unit units;

  92.     /** Number of the line from which pair is extracted. */
  93.     private final int lineNumber;

  95.     /** Name of the file. */
  96.     private final String fileName;

  98.     /** Simple constructor.
  99.      * @param type type of the token
  100.      * @param name name of the block or entry
  101.      * @param content entry content
  102.      * @param units units of the entry
  103.      * @param lineNumber number of the line in the CCSDS data message
  104.      * @param fileName name of the file
  105.      */
  106.     public ParseToken(final TokenType type, final String name, final String content, final Unit units,
  107.                       final int lineNumber, final String fileName) {
  108.         this.type       = type;
  109.         this.name       = name;
  110.         this.content    = content;
  111.         this.units      = units;
  112.         this.lineNumber = lineNumber;
  113.         this.fileName   = fileName;
  114.     }

  116.     /** Get the type of the token.
  117.      * @return type of the token
  118.      */
  119.     public TokenType getType() {
  120.         return type;
  121.     }

  123.     /** Get the name of the block or entry.
  124.      * @return name of the block or entry
  125.      */
  126.     public String getName() {
  127.         return name;
  128.     }

  130.     /** Get the raw content of the entry.
  131.      * @return entry raw content
  132.      */
  133.     public String getRawContent() {
  134.         return content;
  135.     }

  137.     /** Get the content of the entry.
  138.      * <p>
  139.      * Free-text strings are normalized by replacing all occurrences
  140.      * of '_' with space, and collapsing several spaces as one space only.
  141.      * </p>
  142.      * @return entry content
  143.      */
  144.     public String getContentAsNormalizedString() {
  145.         return SPACE.matcher(content.replace('_', ' ')).replaceAll(" ").trim();
  146.     }

  148.     /** Get the content of the entry as a list of free-text strings.
  149.      * <p>
  150.      * Free-text strings are normalized by replacing all occurrences
  151.      * of '_' with space, and collapsing several spaces as one space only.
  152.      * </p>
  153.      * @return content of the entry as a list of free-test strings
  154.      */
  155.     public List<String> getContentAsNormalizedList() {
  156.         return Arrays.asList(SPLIT_AT_COMMAS.split(getContentAsNormalizedString()));
  157.     }

  159.     /** Get the content of the entry as normalized and uppercased.
  160.      * @return entry normalized and uppercased content
  161.      */
  162.     public String getContentAsUppercaseString() {
  163.         return getContentAsNormalizedString().toUpperCase(Locale.US);
  164.     }

  166.     /** Get the content of the entry as a list of normalized and uppercased strings.
  167.      * @return content of the entry as a list of normalized and uppercased strings
  168.      */
  169.     public List<String> getContentAsUppercaseList() {
  170.         return Arrays.asList(SPLIT_AT_COMMAS.split(getContentAsUppercaseString()));
  171.     }

  173.     /** Get the content of the entry as an enum.
  174.      * @param cls enum class
  175.      * @param <T> type of the enum
  176.      * @return entry content
  177.      */
  178.     public <T extends Enum<T>> T getContentAsEnum(final Class<T> cls) {
  179.         return toEnum(cls, getRawContent());
  180.     }

  182.     /** Get the content of the entry as a list of enum.
  183.      * @param cls enum class
  184.      * @param <T> type of the enum
  185.      * @return entry content
  186.      */
  187.     public <T extends Enum<T>> List<T> getContentAsEnumList(final Class<T> cls) {
  188.         final String[] elements = SPLIT_AT_COMMAS.split(getRawContent());
  189.         final List<T> list = new ArrayList<>(elements.length);
  190.         for (int i = 0; i < elements.length; ++i) {
  191.             list.add(toEnum(cls, elements[i]));
  192.         }
  193.         return list;
  194.     }

  196.     /** Get the content of the entry as a double.
  197.      * @return content as a double
  198.      */
  199.     public double getContentAsDouble() {
  200.         try {
  201.             return Double.parseDouble(content);
  202.         } catch (NumberFormatException nfe) {
  203.             throw generateException(nfe);
  204.         }
  205.     }

  207.     /** Get the content of the entry as a vector.
  208.      * @return content as a vector
  209.      */
  210.     public Vector3D getContentAsVector() {
  211.         try {
  212.             final String[] fields = SPACE.split(content);
  213.             if (fields.length == 3) {
  214.                 return new Vector3D(Double.parseDouble(fields[0]),
  215.                                     Double.parseDouble(fields[1]),
  216.                                     Double.parseDouble(fields[2]));
  217.             }
  218.         } catch (NumberFormatException nfe) {
  219.             // ignored, error handled below, together with wrong number of fields
  220.         }
  221.         throw generateException(null);
  222.     }

  224.     /** Get the content of the entry as a boolean.
  225.      * @return content as a boolean
  226.      */
  227.     public boolean getContentAsBoolean() {
  228.         if (BOOLEAN_TRUE.matcher(content).matches()) {
  229.             return true;
  230.         } else if (BOOLEAN_FALSE.matcher(content).matches()) {
  231.             return false;
  232.         } else {
  233.             throw generateException(null);
  234.         }
  235.     }

  237.     /** Get the content of the entry as an integer.
  238.      * @return content as an integer
  239.      */
  240.     public int getContentAsInt() {
  241.         try {
  242.             return Integer.parseInt(content);
  243.         } catch (NumberFormatException nfe) {
  244.             throw generateException(nfe);
  245.         }
  246.     }

  248.     /** Get the content of the entry as an uppercase character.
  249.      * @return content as an uppercase character
  250.      */
  251.     public char getContentAsUppercaseCharacter() {
  252.         try {
  253.             return getContentAsUppercaseString().charAt(0);
  254.         } catch (NumberFormatException nfe) {
  255.             throw generateException(nfe);
  256.         }
  257.     }

  259.     /** Get the units.
  260.      * @return units of the entry (may be null)
  261.      */
  262.     public Unit getUnits() {
  263.         return units;
  264.     }

  266.     /** Get the number of the line in the CCSDS data message.
  267.      * @return number of the line in the CCSDS data message
  268.      */
  269.     public int getLineNumber() {
  270.         return lineNumber;
  271.     }

  273.     /** Get the name of the file.
  274.      * @return name of the file
  275.      */
  276.     public String getFileName() {
  277.         return fileName;
  278.     }

  280.     /** Process the content as a normalized string.
  281.      * @param consumer consumer of the normalized string
  282.      * @return always returns {@code true}
  283.      * @see #processAsUppercaseString(StringConsumer)
  284.      */
  285.     public boolean processAsNormalizedString(final StringConsumer consumer) {
  286.         if (type == TokenType.ENTRY) {
  287.             consumer.accept(getContentAsNormalizedString());
  288.         }
  289.         return true;
  290.     }

  292.     /** Process the content as a normalized uppercase string.
  293.      * @param consumer consumer of the normalized uppercase string
  294.      * @return always returns {@code true}
  295.      * @see #processAsNormalizedString(StringConsumer)
  296.      */
  297.     public boolean processAsUppercaseString(final StringConsumer consumer) {
  298.         if (type == TokenType.ENTRY) {
  299.             consumer.accept(getContentAsUppercaseString());
  300.         }
  301.         return true;
  302.     }

  304.     /** Process the content as an indexed normalized string.
  305.      * @param index index
  306.      * @param consumer consumer of the indexed normalized string
  307.      * @return always returns {@code true}
  308.      */
  309.     public boolean processAsIndexedNormalizedString(final int index, final IndexedStringConsumer consumer) {
  310.         if (type == TokenType.ENTRY) {
  311.             consumer.accept(index, getContentAsNormalizedString());
  312.         }
  313.         return true;
  314.     }

  316.     /** Process the content as an indexed normalized uppercase string.
  317.      * @param index index
  318.      * @param consumer consumer of the indexed normalized uppercase string
  319.      * @return always returns {@code true}
  320.      */
  321.     public boolean processAsIndexedUppercaseString(final int index, final IndexedStringConsumer consumer) {
  322.         if (type == TokenType.ENTRY) {
  323.             consumer.accept(index, getContentAsUppercaseString());
  324.         }
  325.         return true;
  326.     }

  328.     /** Process the content as a list of normalized strings.
  329.      * @param consumer consumer of the normalized strings list
  330.      * @return always returns {@code true}
  331.      */
  332.     public boolean processAsNormalizedList(final StringListConsumer consumer) {
  333.         if (type == TokenType.ENTRY) {
  334.             consumer.accept(getContentAsNormalizedList());
  335.         }
  336.         return true;
  337.     }

  339.     /** Process the content as a list of normalized uppercase strings.
  340.      * @param consumer consumer of the normalized uppercase strings list
  341.      * @return always returns {@code true}
  342.      */
  343.     public boolean processAsUppercaseList(final StringListConsumer consumer) {
  344.         if (type == TokenType.ENTRY) {
  345.             consumer.accept(getContentAsUppercaseList());
  346.         }
  347.         return true;
  348.     }

  350.     /** Process the content as an enum.
  351.      * @param cls enum class
  352.      * @param consumer consumer of the enum
  353.      * @param <T> type of the enum
  354.      * @return always returns {@code true}
  355.      */
  356.     public <T extends Enum<T>> boolean processAsEnum(final Class<T> cls, final EnumConsumer<T> consumer) {
  357.         if (type == TokenType.ENTRY) {
  358.             consumer.accept(getContentAsEnum(cls));
  359.         }
  360.         return true;
  361.     }

  363.     /** Process the content as a list of enums.
  364.      * @param cls enum class
  365.      * @param consumer consumer of the enums list
  366.      * @param <T> type of the enum
  367.      * @return always returns {@code true}
  368.      */
  369.     public <T extends Enum<T>> boolean processAsEnumsList(final Class<T> cls, final EnumListConsumer<T> consumer) {
  370.         if (type == TokenType.ENTRY) {
  371.             consumer.accept(getContentAsEnumList(cls));
  372.         }
  373.         return true;
  374.     }

  376.     /** Process the content as a boolean.
  377.      * @param consumer consumer of the boolean
  378.      * @return always returns {@code true}
  379.      */
  380.     public boolean processAsBoolean(final BooleanConsumer consumer) {
  381.         if (type == TokenType.ENTRY) {
  382.             consumer.accept(getContentAsBoolean());
  383.         }
  384.         return true;
  385.     }

  387.     /** Process the content as an integer.
  388.      * @param consumer consumer of the integer
  389.      * @return always returns {@code true}
  390.      */
  391.     public boolean processAsInteger(final IntConsumer consumer) {
  392.         if (type == TokenType.ENTRY) {
  393.             consumer.accept(getContentAsInt());
  394.         }
  395.         return true;
  396.     }

  398.     /** Process the content as an array of integers. No spaces between commas are allowed.
  399.      * @param consumer consumer of the array
  400.      * @return always returns {@code true}
  401.      */
  402.     public boolean processAsIntegerArrayNoSpace(final IntegerArrayConsumer consumer) {
  403.         try {
  404.             if (type == TokenType.ENTRY) {
  405.                 // Do not allow spaces
  406.                 final String[] fields = SPLIT_AT_COMMAS_NO_SPACE.split(getRawContent());
  407.                 final int[] integers = new int[fields.length];
  408.                 for (int i = 0; i < fields.length; ++i) {
  409.                     integers[i] = Integer.parseInt(fields[i]);
  410.                 }
  411.                 consumer.accept(integers);
  412.             }
  413.             return true;
  414.         } catch (NumberFormatException nfe) {
  415.             throw generateException(nfe);
  416.         }
  417.     }

  419.     /** Process the content as an array of integers. Spaces are replaced by commas.
  420.      * @param consumer consumer of the array
  421.      * @return always returns {@code true}
  422.      */
  423.     public boolean processAsIntegerArray(final IntegerArrayConsumer consumer) {
  424.         try {
  425.             if (type == TokenType.ENTRY) {
  426.                 final String[] fields = SPLIT_AT_COMMAS.split(getRawContent().replace(" ", ","));
  427.                 final int[] integers = new int[fields.length];
  428.                 for (int i = 0; i < fields.length; ++i) {
  429.                     integers[i] = Integer.parseInt(fields[i]);
  430.                 }
  431.                 consumer.accept(integers);
  432.             }
  433.             return true;
  434.         } catch (NumberFormatException nfe) {
  435.             throw generateException(nfe);
  436.         }
  437.     }

  439.     /** Process the content as a normalized character.
  440.      * @param consumer consumer of the normalized character
  441.      * @return always returns {@code true}
  442.      */
  443.     public boolean processAsNormalizedCharacter(final CharConsumer consumer) {
  444.         if (type == TokenType.ENTRY) {
  445.             consumer.accept(getContentAsUppercaseCharacter());
  446.         }
  447.         return true;
  448.     }

  450.     /** Process the content as a double.
  451.      * @param standard units of parsed content as specified by CCSDS standard
  452.      * @param behavior behavior to adopt for parsed unit
  453.      * @param consumer consumer of the double
  454.      * @return always returns {@code true}
  455.      */
  456.     public boolean processAsDouble(final Unit standard, final ParsedUnitsBehavior behavior,
  457.                                    final DoubleConsumer consumer) {
  458.         if (type == TokenType.ENTRY) {
  459.             consumer.accept(behavior.select(getUnits(), standard).toSI(getContentAsDouble()));
  460.         }
  461.         return true;
  462.     }

  464.     /** Process the content as an labeled double.
  465.      * @param label label
  466.      * @param standard units of parsed content as specified by CCSDS standard
  467.      * @param behavior behavior to adopt for parsed unit
  468.      * @param consumer consumer of the indexed double
  469.      * @return always returns {@code true}
  470.      */
  471.     public boolean processAsLabeledDouble(final char label,
  472.                                           final Unit standard, final ParsedUnitsBehavior behavior,
  473.                                           final LabeledDoubleConsumer consumer) {
  474.         if (type == TokenType.ENTRY) {
  475.             consumer.accept(label, behavior.select(getUnits(), standard).toSI(getContentAsDouble()));
  476.         }
  477.         return true;
  478.     }

  480.     /** Process the content as an indexed double.
  481.      * @param i index
  482.      * @param standard units of parsed content as specified by CCSDS standard
  483.      * @param behavior behavior to adopt for parsed unit
  484.      * @param consumer consumer of the indexed double
  485.      * @return always returns {@code true}
  486.      */
  487.     public boolean processAsIndexedDouble(final int i,
  488.                                           final Unit standard, final ParsedUnitsBehavior behavior,
  489.                                           final IndexedDoubleConsumer consumer) {
  490.         if (type == TokenType.ENTRY) {
  491.             consumer.accept(i, behavior.select(getUnits(), standard).toSI(getContentAsDouble()));
  492.         }
  493.         return true;
  494.     }

  496.     /** Process the content as a doubly-indexed double.
  497.      * @param i first index
  498.      * @param j second index
  499.      * @param standard units of parsed content as specified by CCSDS standard
  500.      * @param behavior behavior to adopt for parsed unit
  501.      * @param consumer consumer of the doubly-indexed double
  502.      * @return always returns {@code true}
  503.      */
  504.     public boolean processAsDoublyIndexedDouble(final int i, final int j,
  505.                                                 final Unit standard, final ParsedUnitsBehavior behavior,
  506.                                                 final DoublyIndexedDoubleConsumer consumer) {
  507.         if (type == TokenType.ENTRY) {
  508.             consumer.accept(i, j, behavior.select(getUnits(), standard).toSI(getContentAsDouble()));
  509.         }
  510.         return true;
  511.     }

  513.     /** Process the content as a vector.
  514.      * @param consumer consumer of the vector
  515.      * @return always returns {@code true} (or throws an exception)
  516.      */
  517.     public boolean processAsVector(final VectorConsumer consumer) {
  518.         if (type == TokenType.ENTRY) {
  519.             consumer.accept(getContentAsVector());
  520.         }
  521.         return true;
  522.     }

  524.     /** Process the content as a date.
  525.      * @param consumer consumer of the date
  526.      * @param context context binding
  527.      * @return always returns {@code true} (or throws an exception)
  528.      */
  529.     public boolean processAsDate(final DateConsumer consumer, final ContextBinding context) {
  530.         if (type == TokenType.ENTRY) {
  531.             if (context.getTimeSystem() == null) {
  532.                 throw new OrekitException(OrekitMessages.CCSDS_TIME_SYSTEM_NOT_READ_YET,
  533.                                           getLineNumber(), getFileName());
  534.             }
  535.             consumer.accept(context.getTimeSystem().getConverter(context).parse(content));
  536.         }
  537.         return true;
  538.     }

  540.     /** Process the content as a time system.
  541.      * @param consumer consumer of the time system
  542.      * @return always returns {@code true} (or throws an exception)
  543.      */
  544.     public boolean processAsTimeSystem(final TimeSystemConsumer consumer) {
  545.         if (type == TokenType.ENTRY) {
  546.             consumer.accept(TimeSystem.parse(getContentAsUppercaseString()));
  547.         }
  548.         return true;
  549.     }

  551.     /** Process the content as a frame.
  552.      * @param consumer consumer of the frame
  553.      * @param context context binding
  554.      * @param allowCelestial if true, {@link CelestialBodyFrame} are allowed
  555.      * @param allowOrbit if true, {@link OrbitRelativeFrame} are allowed
  556.      * @param allowSpacecraft if true, {@link SpacecraftBodyFrame} are allowed
  557.      * @return always returns {@code true}
  558.      */
  559.     public boolean processAsFrame(final FrameConsumer consumer, final ContextBinding context,
  560.                                   final boolean allowCelestial, final boolean allowOrbit,
  561.                                   final boolean allowSpacecraft) {
  562.         if (type == TokenType.ENTRY) {
  563.             try {
  564.                 consumer.accept(FrameFacade.parse(DASH.
  565.                                                   matcher(getContentAsUppercaseString()).
  566.                                                   replaceAll("").
  567.                                                   replace(' ', '_'),
  568.                                                   context.getConventions(),
  569.                                                   context.isSimpleEOP(), context.getDataContext(),
  570.                                                   allowCelestial, allowOrbit, allowSpacecraft));
  571.             } catch (OrekitException oe) {
  572.                 throw generateException(oe);
  573.             }
  574.         }
  575.         return true;
  576.     }

  578.     /** Process the content as a body center.
  579.      * @param consumer consumer of the body center
  580.      * @param celestialBodies factory for celestial bodies
  581.      * @return always returns {@code true}
  582.      */
  583.     public boolean processAsCenter(final CenterConsumer consumer, final CelestialBodies celestialBodies) {
  584.         if (type == TokenType.ENTRY) {
  585.             final String centerName = getContentAsUppercaseString();
  586.             consumer.accept(new BodyFacade(centerName, body(centerName, celestialBodies)));
  587.         }
  588.         return true;
  589.     }

  591.     /** Process the content as a body center list.
  592.      * @param consumer consumer of the body center list
  593.      * @param celestialBodies factory for celestial bodies
  594.      * @return always returns {@code true}
  595.      */
  596.     public boolean processAsCenterList(final CenterListConsumer consumer, final CelestialBodies celestialBodies) {
  597.         if (type == TokenType.ENTRY) {
  598.             final List<BodyFacade> facades = new ArrayList<>();
  599.             for (final String centerName : SPLIT_AT_COMMAS.split(getContentAsUppercaseString())) {
  600.                 facades.add(new BodyFacade(centerName, body(centerName, celestialBodies)));
  601.             }
  602.             consumer.accept(facades);
  603.         }
  604.         return true;
  605.     }

  607.     /** Process the content as a list of units.
  608.      * @param consumer consumer of the time scale
  609.      * @return always returns {@code true} (or throws an exception)
  610.      */
  611.     public boolean processAsUnitList(final UnitListConsumer consumer) {
  612.         if (type == TokenType.ENTRY) {
  613.             final String bracketed = getContentAsNormalizedString();
  614.             if (bracketed.charAt(0) != '[' || bracketed.charAt(bracketed.length() - 1) != ']') {
  615.                 throw generateException(null);
  616.             }
  617.             final String unbracketed = bracketed.substring(1, bracketed.length() - 1).trim();
  618.             try {
  619.                 consumer.accept(Stream.of(SPLIT_AT_COMMAS.split(unbracketed)).
  620.                                 map(s -> Unit.parse(s)).
  621.                                 collect(Collectors.toList()));
  622.             } catch (OrekitException oe) {
  623.                 // one unit is unknown
  624.                 throw generateException(oe);
  625.             }
  626.         }
  627.         return true;
  628.     }

  630.      /** Process the content as free text string.
  631.      * @param consumer consumer of the string
  632.      * @return always returns {@code true}
  633.      */
  634.     public boolean processAsFreeTextString(final StringConsumer consumer) {
  635.         if (type == TokenType.ENTRY) {
  636.             consumer.accept(getRawContent());
  637.         }
  638.         return true;
  639.     }

  641.     /** Process the content as an array of doubles.
  642.      * @param consumer consumer of the array
  643.      * @return always returns {@code true}
  644.      */
  645.     public boolean processAsDoubleArray(final DoubleArrayConsumer consumer) {
  646.         try {
  647.             if (type == TokenType.ENTRY) {
  648.                 final String[] fields = SPLIT_AT_COMMAS.split(getRawContent().replace(" ", ","));
  649.                 final double[] doubles = new double[fields.length];
  650.                 for (int i = 0; i < fields.length; ++i) {
  651.                     doubles[i] = Double.parseDouble(fields[i]);
  652.                 }
  653.                 consumer.accept(doubles);
  654.             }
  655.             return true;
  656.         } catch (NumberFormatException nfe) {
  657.             throw generateException(nfe);
  658.         }
  659.     }

  661.     /** Process the content of the Maneuvrable enum.
  662.      * @param consumer consumer of the enum
  663.      * @return always returns {@code true}
  664.      */
  665.     public boolean processAsManeuvrableEnum(final ManeuvrableConsumer consumer) {
  666.         if (type == TokenType.ENTRY) {
  667.             consumer.accept(Maneuvrable.getEnum(getRawContent()));
  668.         }
  669.         return true;
  670.     }

  672.     /** Generate a parse exception for this entry.
  673.      * @param cause underlying cause exception (may be null)
  674.      * @return exception for this entry
  675.      */
  676.     public OrekitException generateException(final Exception cause) {
  677.         return new OrekitException(cause, OrekitMessages.UNABLE_TO_PARSE_ELEMENT_IN_FILE,
  678.                                    getName(), getLineNumber(), getFileName());
  679.     }

  681.     /** Get the body corresponding to a center name.
  682.      * @param centerName name of the center
  683.      * @param celestialBodies factory for celestial bodies
  684.      * @return celestial body corresponding to name, or null
  685.      */
  686.     private CelestialBody body(final String centerName, final CelestialBodies celestialBodies) {

  688.         // convert some known names
  689.         final String canonicalValue;
  690.         if (centerName.equals("SOLAR SYSTEM BARYCENTER") || centerName.equals("SSB")) {
  691.             canonicalValue = "SOLAR_SYSTEM_BARYCENTER";
  692.         } else if (centerName.equals("EARTH MOON BARYCENTER") || centerName.equals("EARTH-MOON BARYCENTER") ||
  693.                         centerName.equals("EARTH BARYCENTER") || centerName.equals("EMB")) {
  694.             canonicalValue = "EARTH_MOON";
  695.         } else {
  696.             canonicalValue = centerName;
  697.         }

  699.         try {
  700.             return CenterName.valueOf(canonicalValue).getCelestialBody(celestialBodies);
  701.         } catch (IllegalArgumentException iae) {
  702.             // ignored, we just let body set to null
  703.             return null;
  704.         }

  706.     }

  708.     /** Convert a value to an enum.
  709.      * @param cls enum class
  710.      * @param value value to convert to an enum
  711.      * @param <T> type of the enum
  712.      * @return enumerate corresponding to the value
  713.      */
  714.     private <T extends Enum<T>> T toEnum(final Class<T> cls, final String value) {
  715.         // first replace space characters
  716.         final String noSpace = value.replace(' ', '_');
  717.         try {
  718.             // first try without changing case, as some CCSDS enums are mixed case (like RangeUnits for TDM)
  719.             return Enum.valueOf(cls, noSpace);
  720.         } catch (IllegalArgumentException iae1) {
  721.             try {
  722.                 // second try, using more standard uppercase
  723.                 return Enum.valueOf(cls, noSpace.toUpperCase(Locale.US));
  724.             } catch (IllegalArgumentException iae2) {
  725.                 // use the first exception for the message
  726.                 throw generateException(iae1);
  727.             }
  728.         }
  729.     }

  731.     /** Interface representing instance methods that consume string values. */
  732.     public interface StringConsumer {
  733.         /** Consume a string.
  734.          * @param value value to consume
  735.          */
  736.         void accept(String value);
  737.     }

  739.     /** Interface representing instance methods that consume indexed string values. */
  740.     public interface IndexedStringConsumer {
  741.         /** Consume an indexed string.
  742.          * @param index index
  743.          * @param value value to consume
  744.          */
  745.         void accept(int index, String value);
  746.     }

  748.     /** Interface representing instance methods that consume lists of strings values. */
  749.     public interface StringListConsumer {
  750.         /** Consume a list of strings.
  751.          * @param value value to consume
  752.          */
  753.         void accept(List<String> value);
  754.     }

  756.     /** Interface representing instance methods that consume enum values.
  757.      * @param <T> type of the enum
  758.      */
  759.     public interface EnumConsumer<T extends Enum<T>> {
  760.         /** Consume an enum.
  761.          * @param value value to consume
  762.          */
  763.         void accept(T value);
  764.     }

  766.     /** Interface representing instance methods that consume lists of enum values.
  767.      * @param <T> type of the enum
  768.      */
  769.     public interface EnumListConsumer<T extends Enum<T>> {
  770.         /** Consume an enum.
  771.          * @param value value to consume
  772.          */
  773.         void accept(List<T> value);
  774.     }

  776.     /** Interface representing instance methods that consume boolean values. */
  777.     public interface BooleanConsumer {
  778.         /** Consume a boolean.
  779.          * @param value value to consume
  780.          */
  781.         void accept(boolean value);
  782.     }

  784.     /** Interface representing instance methods that consume integer values. */
  785.     public interface IntConsumer {
  786.         /** Consume an integer.
  787.          * @param value value to consume
  788.          */
  789.         void accept(int value);
  790.     }

  792.     /** Interface representing instance methods that consume integer array. */
  793.     public interface IntegerArrayConsumer {
  794.         /** Consume an array of integers.
  795.          * @param integers array of integers
  796.          */
  797.         void accept(int[] integers);
  798.     }

  800.     /** Interface representing instance methods that consume character values. */
  801.     public interface CharConsumer {
  802.         /** Consume a character.
  803.          * @param value value to consume
  804.          */
  805.         void accept(char value);
  806.     }

  808.     /** Interface representing instance methods that consume double values. */
  809.     public interface DoubleConsumer {
  810.         /** Consume a double.
  811.          * @param value value to consume
  812.          */
  813.         void accept(double value);
  814.     }

  816.     /** Interface representing instance methods that consume labeled double values. */
  817.     public interface LabeledDoubleConsumer {
  818.         /** Consume an indexed double.
  819.          * @param label label
  820.          * @param value value to consume
  821.          */
  822.         void accept(char label, double value);
  823.     }

  825.     /** Interface representing instance methods that consume indexed double values. */
  826.     public interface IndexedDoubleConsumer {
  827.         /** Consume an indexed double.
  828.          * @param i index
  829.          * @param value value to consume
  830.          */
  831.         void accept(int i, double value);
  832.     }

  834.     /** Interface representing instance methods that consume doubly-indexed double values. */
  835.     public interface DoublyIndexedDoubleConsumer {
  836.         /** Consume a doubly indexed double.
  837.          * @param i first index
  838.          * @param j second index
  839.          * @param value value to consume
  840.          */
  841.         void accept(int i, int j, double value);
  842.     }

  844.     /** Interface representing instance methods that consume vector values. */
  845.     public interface VectorConsumer {
  846.         /** Consume a vector.
  847.          * @param value value to consume
  848.          */
  849.         void accept(Vector3D value);
  850.     }

  852.     /** Interface representing instance methods that consume date values. */
  853.     public interface DateConsumer {
  854.         /** Consume a date.
  855.          * @param value value to consume
  856.          */
  857.         void accept(AbsoluteDate value);
  858.     }

  860.     /** Interface representing instance methods that consume time systems values. */
  861.     public interface TimeSystemConsumer {
  862.         /** Consume a time system.
  863.          * @param value value to consume
  864.          */
  865.         void accept(TimeSystem value);
  866.     }

  868.     /** Interface representing instance methods that consume frame values. */
  869.     public interface FrameConsumer {
  870.         /** Consume a frame.
  871.          * @param frameFacade facade in front of several frames types
  872.          */
  873.         void accept(FrameFacade frameFacade);
  874.     }

  876.     /** Interface representing instance methods that consume center values. */
  877.     public interface CenterConsumer {
  878.         /** Consume a body center.
  879.          * @param bodyFacade facade for celestial body name and body
  880.          */
  881.         void accept(BodyFacade bodyFacade);
  882.     }

  884.     /** Interface representing instance methods that consume center lists. */
  885.     public interface CenterListConsumer {
  886.         /** Consume a body center.
  887.          * @param bodyFacades facades for celestial bodies name and bodies
  888.          */
  889.         void accept(List<BodyFacade> bodyFacades);
  890.     }

  892.     /** Interface representing instance methods that consume units lists values. */
  893.     public interface UnitListConsumer {
  894.         /** Consume a list of units.
  895.          * @param value value to consume
  896.          */
  897.         void accept(List<Unit> value);
  898.     }

  900.     /** Interface representing instance methods that consume double array. */
  901.     public interface DoubleArrayConsumer {
  902.         /** Consume an array of doubles.
  903.          * @param doubles array of doubles
  904.          */
  905.         void accept(double[] doubles);
  906.     }

  908.     /** Interface representing instance methods that consume Maneuvrable values. */
  909.     public interface ManeuvrableConsumer {
  910.         /** Consume a Maneuvrable.
  911.          * @param value value to consume
  912.          */
  913.         void accept(Maneuvrable value);
  914.     }
  915. }
Created with JaCoCo 0.8.8.202204050719