StreamingAemWriter.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.IOException;
  20. import java.text.DecimalFormat;
  21. import java.text.DecimalFormatSymbols;
  22. import java.time.ZoneOffset;
  23. import java.time.ZonedDateTime;
  24. import java.time.format.DateTimeFormatter;
  25. import java.util.Date;
  26. import java.util.LinkedHashMap;
  27. import java.util.Locale;
  28. import java.util.Map;

  30. import org.hipparchus.exception.LocalizedCoreFormats;
  31. import org.hipparchus.geometry.euclidean.threed.RotationOrder;
  32. import org.orekit.errors.OrekitException;
  33. import org.orekit.files.ccsds.AEMParser.AEMRotationOrder;
  34. import org.orekit.propagation.SpacecraftState;
  35. import org.orekit.propagation.sampling.OrekitFixedStepHandler;
  36. import org.orekit.time.AbsoluteDate;
  37. import org.orekit.time.DateTimeComponents;
  38. import org.orekit.time.TimeComponents;
  39. import org.orekit.time.TimeScale;
  40. import org.orekit.utils.TimeStampedAngularCoordinates;

  42. /**
  43.  * A writer for AEM files.
  44.  *
  45.  * <p> Each instance corresponds to a single AEM file.
  46.  *
  47.  * <h2> Metadata </h2>
  48.  *
  49.  * <p> The AEM metadata used by this writer is described in the following table. Many
  50.  * metadata items are optional or have default values so they do not need to be specified.
  51.  * At a minimum the user must supply those values that are required and for which no
  52.  * default exits: {@link Keyword#OBJECT_NAME}, and {@link Keyword#OBJECT_ID}. The usage
  53.  * column in the table indicates where the metadata item is used, either in the AEM header
  54.  * or in the metadata section at the start of an AEM attitude segment.
  55.  *
  56.  * <p> The AEM metadata for the whole AEM file is set in the {@link
  57.  * #StreamingAemWriter(Appendable, TimeScale, Map) constructor}.
  58.  *
  59.  * <table>
  60.  * <caption>AEM metadata</caption>
  61.  *     <thead>
  62.  *         <tr>
  63.  *             <th>Keyword
  64.  *             <th>Usage
  65.  *             <th>Obligatory
  66.  *             <th>Default
  67.  *             <th>Reference
  68.  *    </thead>
  69.  *    <tbody>
  70.  *        <tr>
  71.  *            <td>{@link Keyword#CCSDS_AEM_VERS}
  72.  *            <td>Header
  73.  *            <td>Yes
  74.  *            <td>{@link #CCSDS_AEM_VERS}
  75.  *            <td>Table 4-2
  76.  *        <tr>
  77.  *            <td>{@link Keyword#COMMENT}
  78.  *            <td>Header
  79.  *            <td>No
  80.  *            <td>
  81.  *            <td>Table 4-2
  82.  *        <tr>
  83.  *            <td>{@link Keyword#CREATION_DATE}
  84.  *            <td>Header
  85.  *            <td>Yes
  86.  *            <td>{@link Date#Date() Now}
  87.  *            <td>Table 4-2
  88.  *        <tr>
  89.  *            <td>{@link Keyword#ORIGINATOR}
  90.  *            <td>Header
  91.  *            <td>Yes
  92.  *            <td>{@link #DEFAULT_ORIGINATOR}
  93.  *            <td>Table 4-2
  94.  *        <tr>
  95.  *            <td>{@link Keyword#OBJECT_NAME}
  96.  *            <td>Segment
  97.  *            <td>Yes
  98.  *            <td>
  99.  *            <td>Table 4-3
  100.  *        <tr>
  101.  *            <td>{@link Keyword#OBJECT_ID}
  102.  *            <td>Segment
  103.  *            <td>Yes
  104.  *            <td>
  105.  *            <td>Table 4-3
  106.  *        <tr>
  107.  *            <td>{@link Keyword#CENTER_NAME}
  108.  *            <td>Segment
  109.  *            <td>No
  110.  *            <td>
  111.  *            <td>Table 4-3
  112.  *        <tr>
  113.  *            <td>{@link Keyword#REF_FRAME_A}
  114.  *            <td>Segment
  115.  *            <td>Yes
  116.  *            <td>
  117.  *            <td>Table 4-3
  118.  *        <tr>
  119.  *            <td>{@link Keyword#REF_FRAME_B}
  120.  *            <td>Segment
  121.  *            <td>Yes
  122.  *            <td>
  123.  *            <td>Table 4-3
  124.  *        <tr>
  125.  *            <td>{@link Keyword#ATTITUDE_DIR}
  126.  *            <td>Segment
  127.  *            <td>Yes
  128.  *            <td>
  129.  *            <td>Table 4-3
  130.  *        <tr>
  131.  *            <td>{@link Keyword#TIME_SYSTEM}
  132.  *            <td>Segment
  133.  *            <td>Yes
  134.  *            <td>
  135.  *            <td>Table 4-3, Annex A
  136.  *        <tr>
  137.  *            <td>{@link Keyword#START_TIME}
  138.  *            <td>Segment
  139.  *            <td>Yes
  140.  *            <td>
  141.  *            <td>Table 4-3
  142.  *        <tr>
  143.  *            <td>{@link Keyword#USEABLE_START_TIME}
  144.  *            <td>Segment
  145.  *            <td>No
  146.  *            <td>
  147.  *            <td>Table 4-3
  148.  *        <tr>
  149.  *            <td>{@link Keyword#STOP_TIME}
  150.  *            <td>Segment
  151.  *            <td>Yes
  152.  *            <td>
  153.  *            <td>Table 4-3
  154.  *        <tr>
  155.  *            <td>{@link Keyword#USEABLE_STOP_TIME}
  156.  *            <td>Segment
  157.  *            <td>No
  158.  *            <td>
  159.  *            <td>Table 4-3
  160.  *        <tr>
  161.  *            <td>{@link Keyword#ATTITUDE_TYPE}
  162.  *            <td>Segment
  163.  *            <td>Yes
  164.  *            <td>
  165.  *            <td>Table 4-3, 4-4
  166.  *        <tr>
  167.  *            <td>{@link Keyword#QUATERNION_TYPE}
  168.  *            <td>Segment
  169.  *            <td>No
  170.  *            <td>
  171.  *            <td>Table 4-3, 4-4
  172.  *        <tr>
  173.  *            <td>{@link Keyword#EULER_ROT_SEQ}
  174.  *            <td>Segment
  175.  *            <td>No
  176.  *            <td>
  177.  *            <td>Table 4-3
  178.  *        <tr>
  179.  *            <td>{@link Keyword#RATE_FRAME}
  180.  *            <td>Segment
  181.  *            <td>No
  182.  *            <td>
  183.  *            <td>Table 4-3
  184.  *        <tr>
  185.  *            <td>{@link Keyword#INTERPOLATION_METHOD}
  186.  *            <td>Segment
  187.  *            <td>No
  188.  *            <td>
  189.  *            <td>Table 4-3
  190.  *        <tr>
  191.  *            <td>{@link Keyword#INTERPOLATION_DEGREE}
  192.  *            <td>Segment
  193.  *            <td>No
  194.  *            <td>
  195.  *            <td>Table 4-3
  196.  *    </tbody>
  197.  *</table>
  198.  *
  199.  * <p> The {@link Keyword#TIME_SYSTEM} must be constant for the whole file and is used
  200.  * to interpret all dates except {@link Keyword#CREATION_DATE}. The guessing algorithm
  201.  * is not guaranteed to work so it is recommended to provide values for {@link
  202.  * Keyword#CENTER_NAME} and {@link Keyword#TIME_SYSTEM} to avoid any bugs associated with
  203.  * incorrect guesses.
  204.  *
  205.  * <p> Standardized values for {@link Keyword#TIME_SYSTEM} are GMST, GPS, MET, MRT, SCLK,
  206.  * TAI, TCB, TDB, TT, UT1, and UTC. Standardized values for reference frames
  207.  * are EME2000, GTOD, ICRF, ITRF2000, ITRF-93, ITRF-97, LVLH, RTN, QSW, TOD, TNW, NTW and RSW.
  208.  * Additionally ITRF followed by a four digit year may be used.
  209.  *
  210.  * @author Bryan Cazabonne
  211.  * @see <a href="https://public.ccsds.org/Pubs/504x0b1c1.pdf">CCSDS 504.0-B-1 Attitude Data Messages</a>
  212.  * @see AEMWriter
  213.  * @since 10.2
  214.  */
  215. public class StreamingAemWriter {

  217.     /** Version number implemented. **/
  218.     public static final String CCSDS_AEM_VERS = "1.0";

  220.     /** Default value for {@link Keyword#ORIGINATOR}. */
  221.     public static final String DEFAULT_ORIGINATOR = "OREKIT";

  223.     /**
  224.      * Default format used for attitude ephemeris data output: 5 digits
  225.      * after the decimal point and leading space for positive values.
  226.      */
  227.     public static final String DEFAULT_ATTITUDE_FORMAT = "% .5f";

  229.     /** New line separator for output file. See 5.4.5. */
  230.     private static final String NEW_LINE = "\n";

  232.     /**
  233.      * Standardized locale to use, to ensure files can be exchanged without
  234.      * internationalization issues.
  235.      */
  236.     private static final Locale STANDARDIZED_LOCALE = Locale.US;

  238.     /** String format used for all key/value pair lines. **/
  239.     private static final String KV_FORMAT = "%s = %s%n";

  241.     /** Output stream. */
  242.     private final Appendable writer;

  244.     /** Metadata for this AEM file. */
  245.     private final Map<Keyword, String> metadata;

  247.     /** Time scale for all dates except {@link Keyword#CREATION_DATE}. */
  248.     private final TimeScale timeScale;

  250.     /** Format for attitude ephemeris data output. */
  251.     private final String attitudeFormat;

  253.     /**
  254.      * Create an AEM writer that streams data to the given output stream.
  255.      * {@link #DEFAULT_ATTITUDE_FORMAT Default formatting} will be used for attitude ephemeris data.
  256.      *
  257.      * @param writer    The output stream for the AEM file. Most methods will append data
  258.      *                  to this {@code writer}.
  259.      * @param timeScale for all times in the AEM except {@link Keyword#CREATION_DATE}. See
  260.      *                  Section 4.2.5.4.2 and Annex A.
  261.      * @param metadata  for the satellite.
  262.      */
  263.     public StreamingAemWriter(final Appendable writer,
  264.                               final TimeScale timeScale,
  265.                               final Map<Keyword, String> metadata) {
  266.         this(writer, timeScale, metadata, DEFAULT_ATTITUDE_FORMAT);
  267.     }

  269.     /**
  270.      * Create an AEM writer than streams data to the given output stream as
  271.      * {@link #StreamingAemWriter(Appendable, TimeScale, Map)} with
  272.      * {@link java.util.Formatter format parameters} for attitude ephemeris data.
  273.      *
  274.      * @param writer    The output stream for the AEM file. Most methods will append data
  275.      *                  to this {@code writer}.
  276.      * @param timeScale for all times in the AEM except {@link Keyword#CREATION_DATE}. See
  277.      *                  Section 4.2.5.4.2 and Annex A.
  278.      * @param metadata  for the satellite.
  279.      * @param attitudeFormat format parameters for attitude ephemeris data output.
  280.      * @since 10.3
  281.      */
  282.     public StreamingAemWriter(final Appendable writer,
  283.                               final TimeScale timeScale,
  284.                               final Map<Keyword, String> metadata,
  285.                               final String attitudeFormat) {
  286.         this.writer    = writer;
  287.         this.timeScale = timeScale;
  288.         this.metadata  = new LinkedHashMap<>(metadata);

  290.         // Set default metadata
  291.         this.metadata.putIfAbsent(Keyword.CCSDS_AEM_VERS, CCSDS_AEM_VERS);

  293.         // creation date is informational only
  294.         this.metadata.putIfAbsent(Keyword.CREATION_DATE,
  295.                 ZonedDateTime.now(ZoneOffset.UTC).format(DateTimeFormatter.ISO_INSTANT));
  296.         this.metadata.putIfAbsent(Keyword.ORIGINATOR, DEFAULT_ORIGINATOR);
  297.         this.metadata.putIfAbsent(Keyword.TIME_SYSTEM, timeScale.getName());
  298.         this.attitudeFormat = attitudeFormat;
  299.     }

  301.     /**
  302.      * Write a single key and value to the stream using Key Value Notation (KVN).
  303.      * @param key   the keyword to write
  304.      * @param value the value to write
  305.      * @throws IOException if an I/O error occurs.
  306.      */
  307.     private void writeKeyValue(final Keyword key, final String value) throws IOException {
  308.         writer.append(String.format(STANDARDIZED_LOCALE, KV_FORMAT, key.toString(), value));
  309.     }

  311.     /**
  312.      * Writes the standard AEM header for the file.
  313.      * @throws IOException if the stream cannot write to stream
  314.      */
  315.     public void writeHeader() throws IOException {
  316.         writeKeyValue(Keyword.CCSDS_AEM_VERS, this.metadata.get(Keyword.CCSDS_AEM_VERS));
  317.         final String comment = this.metadata.get(Keyword.COMMENT);
  318.         if (comment != null) {
  319.             writeKeyValue(Keyword.COMMENT, comment);
  320.         }
  321.         writeKeyValue(Keyword.CREATION_DATE, this.metadata.get(Keyword.CREATION_DATE));
  322.         writeKeyValue(Keyword.ORIGINATOR, this.metadata.get(Keyword.ORIGINATOR));
  323.         writer.append(NEW_LINE);
  324.     }

  326.     /**
  327.      * Create a writer for a new AEM attitude ephemeris segment.
  328.      * <p> The returned writer can only write a single attitude ephemeris segment in an AEM.
  329.      * This method must be called to create a writer for each attitude ephemeris segment.
  330.      * @param segmentMetadata the metadata to use for the segment. Overrides for this
  331.      *                        segment any other source of meta data values. See {@link
  332.      *                        #StreamingAemWriter} for a description of which metadata are
  333.      *                        required and how they are determined.
  334.      * @return a new AEM segment, ready for writing.
  335.      */
  336.     public AEMSegment newSegment(final Map<Keyword, String> segmentMetadata) {
  337.         final Map<Keyword, String> meta = new LinkedHashMap<>(this.metadata);
  338.         meta.putAll(segmentMetadata);
  339.         return new AEMSegment(meta);
  340.     }

  342.     /**
  343.      * Convert a date to a string with more precision.
  344.      *
  345.      * @param components to convert to a String.
  346.      * @return the String form of {@code date} with at least 9 digits of precision.
  347.      */
  348.     static String dateToString(final DateTimeComponents components) {
  349.         final TimeComponents time = components.getTime();
  350.         final int hour = time.getHour();
  351.         final int minute = time.getMinute();
  352.         final double second = time.getSecond();
  353.         // Decimal formatting classes could be static final if they were thread safe.
  354.         final DecimalFormatSymbols locale = new DecimalFormatSymbols(STANDARDIZED_LOCALE);
  355.         final DecimalFormat twoDigits = new DecimalFormat("00", locale);
  356.         final DecimalFormat precise = new DecimalFormat("00.0########", locale);
  357.         return components.getDate().toString() + "T" + twoDigits.format(hour) + ":" +
  358.                 twoDigits.format(minute) + ":" + precise.format(second);
  359.     }

  361.     /** A writer for a segment of an AEM. */
  362.     public class AEMSegment implements OrekitFixedStepHandler {

  364.         /** Metadata for this AEM Segment. */
  365.         private final Map<Keyword, String> metadata;

  367.         /**
  368.          * Create a new segment writer.
  369.          * @param metadata to use when writing this segment.
  370.          */
  371.         private AEMSegment(final Map<Keyword, String> metadata) {
  372.             this.metadata = metadata;
  373.         }

  375.         /**
  376.          * Write the ephemeris segment metadata.
  377.          *
  378.          * <p> See {@link StreamingAemWriter} for a description of how the metadata is
  379.          * set.
  380.          *
  381.          * @throws IOException if the output stream throws one while writing.
  382.          */
  383.         public void writeMetadata() throws IOException {
  384.             // Start metadata
  385.             writer.append("META_START").append(NEW_LINE);

  387.             // Table 4.3
  388.             writeKeyValue(Keyword.OBJECT_NAME,  this.metadata.get(Keyword.OBJECT_NAME));
  389.             writeKeyValue(Keyword.OBJECT_ID,    this.metadata.get(Keyword.OBJECT_ID));
  390.             writeKeyValue(Keyword.CENTER_NAME,  this.metadata.get(Keyword.CENTER_NAME));
  391.             writeKeyValue(Keyword.REF_FRAME_A,  this.metadata.get(Keyword.REF_FRAME_A));
  392.             writeKeyValue(Keyword.REF_FRAME_B,  this.metadata.get(Keyword.REF_FRAME_B));
  393.             writeKeyValue(Keyword.ATTITUDE_DIR, this.metadata.get(Keyword.ATTITUDE_DIR));
  394.             writeKeyValue(Keyword.TIME_SYSTEM,  this.metadata.get(Keyword.TIME_SYSTEM));
  395.             writeKeyValue(Keyword.START_TIME,   this.metadata.get(Keyword.START_TIME));

  397.             // Optional values: USEABLE_START_TIME & USEABLE_STOP_TIME
  398.             final String usableStartTime = this.metadata.get(Keyword.USEABLE_START_TIME);
  399.             if (usableStartTime != null) {
  400.                 writeKeyValue(Keyword.USEABLE_START_TIME, usableStartTime);
  401.             }
  402.             final String usableStopTime = this.metadata.get(Keyword.USEABLE_STOP_TIME);
  403.             if (usableStopTime != null) {
  404.                 writeKeyValue(Keyword.USEABLE_STOP_TIME, usableStopTime);
  405.             }

  407.             // Table 4.3
  408.             writeKeyValue(Keyword.STOP_TIME,     this.metadata.get(Keyword.STOP_TIME));
  409.             writeKeyValue(Keyword.ATTITUDE_TYPE, this.metadata.get(Keyword.ATTITUDE_TYPE));

  411.             // Optional values: QUATERNION_ TYPE; EULER_ROT_SEQ; RATE_FRAME; INTERPOLATION_METHOD and INTERPOLATION_DEGREE
  412.             final String quaternionType = this.metadata.get(Keyword.QUATERNION_TYPE);
  413.             if (quaternionType != null) {
  414.                 writeKeyValue(Keyword.QUATERNION_TYPE, quaternionType);
  415.             }
  416.             final String eulerRotSeq = this.metadata.get(Keyword.EULER_ROT_SEQ);
  417.             if (eulerRotSeq != null) {
  418.                 writeKeyValue(Keyword.EULER_ROT_SEQ, eulerRotSeq);
  419.             }
  420.             final String rateFrame = this.metadata.get(Keyword.RATE_FRAME);
  421.             if (rateFrame != null) {
  422.                 writeKeyValue(Keyword.RATE_FRAME, rateFrame);
  423.             }
  424.             final String interpolationMethod = this.metadata.get(Keyword.INTERPOLATION_METHOD);
  425.             if (interpolationMethod != null) {
  426.                 writeKeyValue(Keyword.INTERPOLATION_METHOD, interpolationMethod);
  427.             }
  428.             final String interpolationDegree = this.metadata.get(Keyword.INTERPOLATION_DEGREE);
  429.             if (interpolationDegree != null) {
  430.                 writeKeyValue(Keyword.INTERPOLATION_DEGREE, interpolationDegree);
  431.             }

  433.             // Stop metadata
  434.             writer.append("META_STOP").append(NEW_LINE).append(NEW_LINE);
  435.         }

  437.         /**
  438.          * Write a single attitude ephemeris line according to section 4.2.4 and Table 4-4.
  439.          * @param attitude the attitude information for a given date.
  440.          * @param isFirst true if QC is the first element in the attitude data
  441.          * @param attitudeName name of the attitude type
  442.          * @param rotationOrder rotation order
  443.          * @throws IOException if the output stream throws one while writing.
  444.          */
  445.         public void writeAttitudeEphemerisLine(final TimeStampedAngularCoordinates attitude,
  446.                                                final boolean isFirst,
  447.                                                final String attitudeName,
  448.                                                final RotationOrder rotationOrder)
  449.             throws IOException {
  450.             // Epoch
  451.             final String epoch = dateToString(attitude.getDate().getComponents(timeScale));
  452.             writer.append(epoch).append(" ");
  453.             // Attitude data in degrees
  454.             final AEMAttitudeType type = AEMAttitudeType.getAttitudeType(attitudeName);
  455.             final double[]        data = type.getAttitudeData(attitude, isFirst, rotationOrder);
  456.             final int             size = data.length;
  457.             for (int index = 0; index < size; index++) {
  458.                 writer.append(String.format(STANDARDIZED_LOCALE, attitudeFormat, data[index]));
  459.                 final String space = (index == size - 1) ? "" : " ";
  460.                 writer.append(space);
  461.             }
  462.             // end the line
  463.             writer.append(NEW_LINE);
  464.         }

  466.         /**
  467.          * {@inheritDoc}
  468.          *
  469.          * <p> Sets the {@link Keyword#START_TIME} and {@link Keyword#STOP_TIME} in this
  470.          * segment's metadata if not already set by the user. Then calls {@link
  471.          * #writeMetadata()} to start the segment.
  472.          */
  473.         @Override
  474.         public void init(final SpacecraftState s0,
  475.                          final AbsoluteDate t,
  476.                          final double step) {
  477.             try {
  478.                 final String start = dateToString(s0.getDate().getComponents(timeScale));
  479.                 final String stop = dateToString(t.getComponents(timeScale));
  480.                 this.metadata.putIfAbsent(Keyword.START_TIME, start);
  481.                 this.metadata.putIfAbsent(Keyword.STOP_TIME, stop);
  482.                 this.writeMetadata();
  483.             } catch (IOException e) {
  484.                 throw new OrekitException(e, LocalizedCoreFormats.SIMPLE_MESSAGE,
  485.                         e.getLocalizedMessage());
  486.             }
  487.         }

  489.         /** {@inheritDoc}. */
  490.         @Override
  491.         public void handleStep(final SpacecraftState currentState, final boolean isLast) {
  492.             try {

  494.                 // Quaternion type
  495.                 final String quaternionType = this.metadata.get(Keyword.QUATERNION_TYPE);
  496.                 // If the QUATERNION_TYPE keyword is not present in the file, this means that
  497.                 // the attitude data are not given using quaternion. Therefore, the computation
  498.                 // of the attitude data will not be sensitive to this parameter. A default value
  499.                 // can be set
  500.                 boolean isFirst = false;
  501.                 if (quaternionType != null) {
  502.                     isFirst = (quaternionType.equals("FIRST")) ? true : false;
  503.                 }

  505.                 // Attitude type
  506.                 final String attitudeType = this.metadata.get(Keyword.ATTITUDE_TYPE);

  508.                 // Rotation order
  509.                 final String eulerRotSeq = this.metadata.get(Keyword.EULER_ROT_SEQ);
  510.                 final RotationOrder order = (eulerRotSeq == null) ? null : AEMRotationOrder.getRotationOrder(eulerRotSeq);

  512.                 // Write attitude ephemeris data
  513.                 writeAttitudeEphemerisLine(currentState.getAttitude().getOrientation(), isFirst,
  514.                                            attitudeType, order);

  516.             } catch (IOException e) {
  517.                 throw new OrekitException(e, LocalizedCoreFormats.SIMPLE_MESSAGE,
  518.                         e.getLocalizedMessage());
  519.             }

  521.         }

  523.         /**
  524.          * Start of an attitude block.
  525.          * @throws IOException if the output stream throws one while writing.
  526.          */
  527.         void startAttitudeBlock() throws IOException {
  528.             writer.append("DATA_START").append(NEW_LINE);
  529.         }

  531.         /**
  532.          * End of an attitude block.
  533.          * @throws IOException if the output stream throws one while writing.
  534.          */
  535.         void endAttitudeBlock() throws IOException {
  536.             writer.append("DATA_STOP").append(NEW_LINE);
  537.         }

  539.     }

  541. }
Created with JaCoCo 0.8.6.202009150832