CPFParser.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.ilrs;

  19. import java.io.BufferedReader;
  20. import java.io.IOException;
  21. import java.io.InputStream;
  22. import java.io.InputStreamReader;
  23. import java.nio.charset.StandardCharsets;
  24. import java.nio.file.Files;
  25. import java.nio.file.Paths;
  26. import java.util.Optional;
  27. import java.util.regex.Pattern;
  28. import java.util.stream.Stream;

  30. import org.hipparchus.geometry.euclidean.threed.Vector3D;
  31. import org.orekit.annotation.DefaultDataContext;
  32. import org.orekit.data.DataContext;
  33. import org.orekit.errors.OrekitException;
  34. import org.orekit.errors.OrekitMessages;
  35. import org.orekit.files.general.EphemerisFileParser;
  36. import org.orekit.files.ilrs.CPFFile.CPFCoordinate;
  37. import org.orekit.frames.Frame;
  38. import org.orekit.frames.Frames;
  39. import org.orekit.time.AbsoluteDate;
  40. import org.orekit.time.DateComponents;
  41. import org.orekit.time.TimeScale;
  42. import org.orekit.utils.CartesianDerivativesFilter;
  43. import org.orekit.utils.Constants;
  44. import org.orekit.utils.IERSConventions;

  46. /**
  47.  * A parser for the CPF orbit file format.
  48.  * <p>
  49.  * It supports both 1.0 and 2.0 versions
  50.  * <p>
  51.  * <b>Note:</b> Only required header keys are read. Furthermore, only position data are read.
  52.  * Other keys are simply ignored
  53.  * Contributions are welcome to support more fields in the format.
  54.  * </p>
  55.  * @see <a href="https://ilrs.gsfc.nasa.gov/docs/2006/cpf_1.01.pdf">1.0 file format</a>
  56.  * @see <a href="https://ilrs.gsfc.nasa.gov/docs/2018/cpf_2.00h-1.pdf">2.0 file format</a>
  57.  * @author Bryan Cazabonne
  58.  * @since 10.3
  59.  */
  60. public class CPFParser implements EphemerisFileParser {

  62.     /** File format. */
  63.     private static final String FILE_FORMAT = "CPF";

  65.     /** Miscroseconds to seconds converter. */
  66.     private static final double MS_TO_S = 1.0e-6;

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

  71.     /** Default number of sample for interpolating data (See: reference documents. */
  72.     private static final int DEFAULT_INTERPOLATION_SAMPLE = 10;

  74.     /** Standard gravitational parameter in m^3 / s^2. */
  75.     private final double mu;

  77.     /** Time scale used to define epochs in CPF file. */
  78.     private final TimeScale timeScale;

  80.     /** Set of frames. */
  81.     private final Frames frames;

  83.     /** Interpolation sample for data interpolating. */
  84.     private final int interpolationSample;

  86.     /** IERS convention for frames. */
  87.     private final IERSConventions iersConvention;

  89.     /**
  90.      * Default constructor.
  91.      * <p>
  92.      * This constructor uses the {@link DataContext#getDefault() default data context}.
  93.      */
  94.     @DefaultDataContext
  95.     public CPFParser() {
  96.         this(Constants.EIGEN5C_EARTH_MU, DEFAULT_INTERPOLATION_SAMPLE,
  97.              IERSConventions.IERS_2010, DataContext.getDefault().getTimeScales().getUTC(),
  98.              DataContext.getDefault().getFrames());
  99.     }

  101.     /**
  102.      * Constructor.
  103.      * @param mu standard gravitational parameter to use for
  104.      *           creating {@link org.orekit.orbits.Orbit Orbits} from
  105.      *           the ephemeris data.
  106.      * @param interpolationSamples number of samples to use when interpolating
  107.      * @param iersConventions IERS convention for frames definition
  108.      * @param utc time scale used to define epochs in CPF files (UTC)
  109.      * @param frames set of frames for satellite coordinates
  110.      */
  111.     public CPFParser(final double mu,
  112.                      final int interpolationSamples,
  113.                      final IERSConventions iersConventions,
  114.                      final TimeScale utc,
  115.                      final Frames frames) {
  116.         this.mu                  = mu;
  117.         this.interpolationSample = interpolationSamples;
  118.         this.iersConvention      = iersConventions;
  119.         this.timeScale           = utc;
  120.         this.frames              = frames;
  121.     }

  123.     /**
  124.      * Parse a CPF file from an input stream using the UTF-8 charset.
  125.      *
  126.      * <p> This method creates a {@link BufferedReader} from the stream and as such this
  127.      * method may read more data than necessary from {@code stream} and the additional
  128.      * data will be lost. The other parse methods do not have this issue.
  129.      *
  130.      * @param stream to read the CPF file from.
  131.      * @return a parsed CPF file.
  132.      * @throws IOException if {@code stream} throws one.
  133.      * @see #parse(String)
  134.      * @see #parse(BufferedReader, String)
  135.      */
  136.     public CPFFile parse(final InputStream stream) throws IOException {
  137.         try (BufferedReader reader = new BufferedReader(new InputStreamReader(stream, StandardCharsets.UTF_8))) {
  138.             return parse(reader, stream.toString());
  139.         }
  140.     }

  142.     /** {@inheritDoc} */
  143.     @Override
  144.     public CPFFile parse(final String fileName) throws IOException {
  145.         try (BufferedReader reader = Files.newBufferedReader(Paths.get(fileName),
  146.                                                              StandardCharsets.UTF_8)) {
  147.             return parse(reader, fileName);
  148.         }
  149.     }

  151.     /** {@inheritDoc} */
  152.     @Override
  153.     public CPFFile parse(final BufferedReader reader,
  154.                          final String fileName) throws IOException {

  156.         // initialize internal data structures
  157.         final ParseInfo pi = new ParseInfo();

  159.         int lineNumber = 0;
  160.         Stream<LineParser> parsers = Stream.of(LineParser.H1);
  161.         for (String line = reader.readLine(); line != null; line = reader.readLine()) {
  162.             ++lineNumber;
  163.             final String l = line;
  164.             final Optional<LineParser> selected = parsers.filter(p -> p.canHandle(l)).findFirst();
  165.             if (selected.isPresent()) {
  166.                 try {
  167.                     selected.get().parse(line, pi);
  168.                 } catch (StringIndexOutOfBoundsException | NumberFormatException e) {
  169.                     throw new OrekitException(e,
  170.                                               OrekitMessages.UNABLE_TO_PARSE_LINE_IN_FILE,
  171.                                               lineNumber, fileName, line);
  172.                 }
  173.                 parsers = selected.get().allowedNext();
  174.             }
  175.             if (pi.done) {
  176.                 pi.file.setFilter(pi.hasVelocityEntries ?
  177.                                   CartesianDerivativesFilter.USE_PV :
  178.                                   CartesianDerivativesFilter.USE_P);
  179.                 // Return file
  180.                 return pi.file;
  181.             }
  182.         }

  184.         // We never reached the EOF marker
  185.         throw new OrekitException(OrekitMessages.CPF_UNEXPECTED_END_OF_FILE, lineNumber);

  187.     }

  189.     /** Transient data used for parsing a CPF file. The data is kept in a
  190.      * separate data structure to make the parser thread-safe.
  191.      * <p><b>Note</b>: The class intentionally does not provide accessor
  192.      * methods, as it is only used internally for parsing a CPF file.</p>
  193.      */
  194.     private class ParseInfo {

  196.         /** The corresponding CPF file. */
  197.         private CPFFile file;

  199.         /** IERS convention. */
  200.         private IERSConventions convention;

  202.         /** Set of frames. */
  203.         private Frames frames;

  205.         /** Frame for the ephemeris data. */
  206.         private Frame frame;

  208.         /** Time scale. */
  209.         private TimeScale timeScale;

  211.         /** Indicates if the SP3 file has velocity entries. */
  212.         private boolean hasVelocityEntries;

  214.         /** End Of File reached indicator. */
  215.         private boolean done;

  217.         /**
  218.          * Constructor.
  219.          */
  220.         protected ParseInfo() {

  222.             // Initialise file
  223.             file = new CPFFile();

  225.             // Time scale
  226.             this.timeScale = CPFParser.this.timeScale;

  228.             // Initialise fields
  229.             file.setMu(mu);
  230.             file.setInterpolationSample(interpolationSample);
  231.             file.setTimeScale(timeScale);

  233.             // Default values
  234.             this.done               = false;
  235.             this.hasVelocityEntries = false;

  237.             // Default value for reference frame
  238.             this.convention = CPFParser.this.iersConvention;
  239.             this.frames     = CPFParser.this.frames;
  240.             frame           = frames.getITRF(convention, false);

  242.         }

  244.     }

  246.     /** Parsers for specific lines. */
  247.     private enum LineParser {

  249.         /** Header first line. */
  250.         H1("H1") {

  252.             /** {@inheritDoc} */
  253.             @Override
  254.             public void parse(final String line, final ParseInfo pi) {

  256.                 // Data contained in the line
  257.                 final String[] values = SEPARATOR.split(line);

  259.                 // Index for reading data.
  260.                 // Allow taking into consideration difference between 1.0 and 2.0 formats
  261.                 int index = 1;

  263.                 // Format
  264.                 final String format = values[index++];

  266.                 // Throw an exception if format is not equal to "CPF"
  267.                 if (!FILE_FORMAT.equals(format)) {
  268.                     throw new OrekitException(OrekitMessages.UNEXPECTED_FORMAT_FOR_ILRS_FILE, FILE_FORMAT, format);
  269.                 }

  271.                 // Fill first elements
  272.                 pi.file.getHeader().setFormat(format);
  273.                 pi.file.getHeader().setVersion(Integer.parseInt(values[index++]));
  274.                 pi.file.getHeader().setSource(values[index++]);

  276.                 // Epoch of ephemeris production
  277.                 final int year  = Integer.parseInt(values[index++]);
  278.                 final int month = Integer.parseInt(values[index++]);
  279.                 final int day   = Integer.parseInt(values[index++]);
  280.                 pi.file.getHeader().setProductionEpoch(new DateComponents(year, month, day));

  282.                 // Hour of ephemeris production
  283.                 pi.file.getHeader().setProductionHour(Integer.parseInt(values[index++]));

  285.                 // Ephemeris sequence number
  286.                 pi.file.getHeader().setSequenceNumber(Integer.parseInt(values[index++]));

  288.                 // Difference between version 1.0 and 2.0: sub-daily ephemeris sequence number
  289.                 if (pi.file.getHeader().getVersion() == 2) {
  290.                     pi.file.getHeader().setSubDailySequenceNumber(Integer.parseInt(values[index++]));
  291.                 }

  293.                 // Target Name
  294.                 pi.file.getHeader().setName(values[index]);

  296.             }

  298.             /** {@inheritDoc} */
  299.             @Override
  300.             public Stream<LineParser> allowedNext() {
  301.                 return Stream.of(H2, ZERO);
  302.             }

  304.         },

  306.         /** Header second line. */
  307.         H2("H2") {

  309.             /** {@inheritDoc} */
  310.             @Override
  311.             public void parse(final String line, final ParseInfo pi) {

  313.                 // Data contained in the line
  314.                 final String[] values = SEPARATOR.split(line);

  316.                 // Identifiers
  317.                 pi.file.getHeader().setIlrsSatelliteId(values[1]);
  318.                 pi.file.getHeader().setSic(values[2]);
  319.                 pi.file.getHeader().setNoradId(values[3]);

  321.                 // Start epoch
  322.                 final int    yearS   = Integer.parseInt(values[4]);
  323.                 final int    monthS  = Integer.parseInt(values[5]);
  324.                 final int    dayS    = Integer.parseInt(values[6]);
  325.                 final int    hourS   = Integer.parseInt(values[7]);
  326.                 final int    minuteS = Integer.parseInt(values[8]);
  327.                 final double secondS = Integer.parseInt(values[9]);

  329.                 pi.file.getHeader().setStartEpoch(new AbsoluteDate(yearS, monthS, dayS,
  330.                                                                    hourS, minuteS, secondS,
  331.                                                                    pi.file.getTimeScale()));

  333.                 // End epoch
  334.                 final int    yearE   = Integer.parseInt(values[10]);
  335.                 final int    monthE  = Integer.parseInt(values[11]);
  336.                 final int    dayE    = Integer.parseInt(values[12]);
  337.                 final int    hourE   = Integer.parseInt(values[13]);
  338.                 final int    minuteE = Integer.parseInt(values[14]);
  339.                 final double secondE = Integer.parseInt(values[15]);

  341.                 pi.file.getHeader().setEndEpoch(new AbsoluteDate(yearE, monthE, dayE,
  342.                                                                  hourE, minuteE, secondE,
  343.                                                                  pi.file.getTimeScale()));

  345.                 // Time between table entries
  346.                 pi.file.getHeader().setStep(Integer.parseInt(values[16]));

  348.                 // Compatibility with TIVs
  349.                 pi.file.getHeader().setIsCompatibleWithTIVs(Integer.parseInt(values[17]) == 1);

  351.                 // Target class
  352.                 pi.file.getHeader().setTargetClass(Integer.parseInt(values[18]));

  354.                 // Reference frame
  355.                 final int frameId = Integer.parseInt(values[19]);
  356.                 switch (frameId) {
  357.                     case 0:
  358.                         pi.frame = pi.frames.getITRF(pi.convention, false);
  359.                         break;
  360.                     case 1:
  361.                         pi.frame = pi.frames.getTOD(true);
  362.                         break;
  363.                     case 2:
  364.                         pi.frame = pi.frames.getMOD(pi.convention);
  365.                         break;
  366.                     default:
  367.                         pi.frame = pi.frames.getITRF(pi.convention, false);
  368.                         break;
  369.                 }
  370.                 pi.file.getHeader().setRefFrame(pi.frame);
  371.                 pi.file.getHeader().setRefFrameId(frameId);

  373.                 // Last fields
  374.                 pi.file.getHeader().setRotationalAngleType(Integer.parseInt(values[20]));
  375.                 pi.file.getHeader().setIsCenterOfMassCorrectionApplied(Integer.parseInt(values[21]) == 1);
  376.                 if (pi.file.getHeader().getVersion() == 2) {
  377.                     pi.file.getHeader().setTargetLocation(Integer.parseInt(values[22]));
  378.                 }

  380.             }

  382.             /** {@inheritDoc} */
  383.             @Override
  384.             public Stream<LineParser> allowedNext() {
  385.                 return Stream.of(H3, H4, H5, H9, ZERO);
  386.             }

  388.         },

  390.         /** Header third line. */
  391.         H3("H3") {

  393.             /** {@inheritDoc} */
  394.             @Override
  395.             public void parse(final String line, final ParseInfo pi) {
  396.                 // Not implemented yet
  397.             }

  399.             /** {@inheritDoc} */
  400.             @Override
  401.             public Stream<LineParser> allowedNext() {
  402.                 return Stream.of(H4, H5, H9, ZERO);
  403.             }

  405.         },

  407.         /** Header fourth line. */
  408.         H4("H4") {

  410.             /** {@inheritDoc} */
  411.             @Override
  412.             public void parse(final String line, final ParseInfo pi) {

  414.                 // Data contained in the line
  415.                 final String[] values = SEPARATOR.split(line);

  417.                 // Pulse Repetition Frequency (PRF)
  418.                 pi.file.getHeader().setPrf(Double.parseDouble(values[1]));

  420.                 // Transponder information
  421.                 pi.file.getHeader().setTranspTransmitDelay(Double.parseDouble(values[2]) * MS_TO_S);
  422.                 pi.file.getHeader().setTranspUtcOffset(Double.parseDouble(values[3]) * MS_TO_S);
  423.                 pi.file.getHeader().setTranspOscDrift(Double.parseDouble(values[4]));
  424.                 if (pi.file.getHeader().getVersion() == 2) {
  425.                     pi.file.getHeader().setTranspClkRef(Double.parseDouble(values[5]));
  426.                 }

  428.             }

  430.             /** {@inheritDoc} */
  431.             @Override
  432.             public Stream<LineParser> allowedNext() {
  433.                 return Stream.of(H5, H9, ZERO);
  434.             }

  436.         },

  438.         /** Header fifth line. */
  439.         H5("H5") {

  441.             /** {@inheritDoc} */
  442.             @Override
  443.             public void parse(final String line, final ParseInfo pi) {

  445.                 // Approximate center of mass to reflector offset in meters
  446.                 final double offset = Double.parseDouble(SEPARATOR.split(line)[1]);
  447.                 pi.file.getHeader().setCenterOfMassOffset(offset);

  449.             }

  451.             /** {@inheritDoc} */
  452.             @Override
  453.             public Stream<LineParser> allowedNext() {
  454.                 return Stream.of(H9, ZERO);
  455.             }

  457.         },

  459.         /** Header last line. */
  460.         H9("H9") {

  462.             /** {@inheritDoc} */
  463.             @Override
  464.             public void parse(final String line, final ParseInfo pi) {
  465.                 // End of header. Nothing to do
  466.             }

  468.             /** {@inheritDoc} */
  469.             @Override
  470.             public Stream<LineParser> allowedNext() {
  471.                 return Stream.of(TEN, ZERO);
  472.             }

  474.         },

  476.         /** Position values. */
  477.         TEN("10") {

  479.             /** {@inheritDoc} */
  480.             @Override
  481.             public void parse(final String line, final ParseInfo pi) {

  483.                 // Data contained in the line
  484.                 final String[] values = SEPARATOR.split(line);

  486.                 // Epoch
  487.                 final int mjd           = Integer.parseInt(values[2]);
  488.                 final double secInDay   = Double.parseDouble(values[3]);
  489.                 final AbsoluteDate date = AbsoluteDate.createMJDDate(mjd, secInDay, pi.timeScale);

  491.                 // Leap second flag
  492.                 final int leap = Integer.parseInt(values[4]);

  494.                 // Coordinates
  495.                 final double x = Double.parseDouble(values[5]);
  496.                 final double y = Double.parseDouble(values[6]);
  497.                 final double z = Double.parseDouble(values[7]);
  498.                 final Vector3D position = new Vector3D(x, y, z);

  500.                 // CPF coordinate
  501.                 final CPFCoordinate coordinate =
  502.                                 new CPFCoordinate(date, position, leap);
  503.                 pi.file.addSatelliteCoordinate(coordinate);

  505.             }

  507.             /** {@inheritDoc} */
  508.             @Override
  509.             public Stream<LineParser> allowedNext() {
  510.                 return Stream.of(TEN, TWENTY, THIRTY, FORTY, FIFTY, SIXTY, SEVENTY, ZERO, EOF);
  511.             }

  513.         },

  515.         /** Velocity values. */
  516.         TWENTY("20") {

  518.             /** {@inheritDoc} */
  519.             @Override
  520.             public void parse(final String line, final ParseInfo pi) {
  521.                 // Not implemented yet
  522.             }

  524.             /** {@inheritDoc} */
  525.             @Override
  526.             public Stream<LineParser> allowedNext() {
  527.                 return Stream.of(TEN, TWENTY, THIRTY, FORTY, FIFTY, SIXTY, SEVENTY, ZERO, EOF);
  528.             }

  530.         },

  532.         /** Corrections. */
  533.         THIRTY("30") {

  535.             /** {@inheritDoc} */
  536.             @Override
  537.             public void parse(final String line, final ParseInfo pi) {
  538.                 // Not implemented yet
  539.             }

  541.             /** {@inheritDoc} */
  542.             @Override
  543.             public Stream<LineParser> allowedNext() {
  544.                 return Stream.of(TEN, TWENTY, THIRTY, FORTY, FIFTY, SIXTY, SEVENTY, ZERO, EOF);
  545.             }

  547.         },

  549.         /** Transponder specific. */
  550.         FORTY("40") {

  552.             /** {@inheritDoc} */
  553.             @Override
  554.             public void parse(final String line, final ParseInfo pi) {
  555.                 // Not implemented yet
  556.             }

  558.             /** {@inheritDoc} */
  559.             @Override
  560.             public Stream<LineParser> allowedNext() {
  561.                 return Stream.of(TEN, TWENTY, THIRTY, FORTY, FIFTY, SIXTY, SEVENTY, ZERO, EOF);
  562.             }

  564.         },

  566.         /** Offset from center of main body. */
  567.         FIFTY("50") {

  569.             /** {@inheritDoc} */
  570.             @Override
  571.             public void parse(final String line, final ParseInfo pi) {
  572.                 // Not implemented yet
  573.             }

  575.             /** {@inheritDoc} */
  576.             @Override
  577.             public Stream<LineParser> allowedNext() {
  578.                 return Stream.of(TEN, TWENTY, THIRTY, FORTY, FIFTY, SIXTY, SEVENTY, ZERO, EOF);
  579.             }

  581.         },

  583.         /** Rotation angle of offset. */
  584.         SIXTY("60") {

  586.             /** {@inheritDoc} */
  587.             @Override
  588.             public void parse(final String line, final ParseInfo pi) {
  589.                 // Not implemented yet
  590.             }

  592.             /** {@inheritDoc} */
  593.             @Override
  594.             public Stream<LineParser> allowedNext() {
  595.                 return Stream.of(TEN, TWENTY, THIRTY, FORTY, FIFTY, SIXTY, SEVENTY, ZERO, EOF);
  596.             }

  598.         },

  600.         /** Earth orientation. */
  601.         SEVENTY("70") {

  603.             /** {@inheritDoc} */
  604.             @Override
  605.             public void parse(final String line, final ParseInfo pi) {
  606.                 // Not implemented yet
  607.             }

  609.             /** {@inheritDoc} */
  610.             @Override
  611.             public Stream<LineParser> allowedNext() {
  612.                 return Stream.of(TEN, TWENTY, THIRTY, FORTY, FIFTY, SIXTY, SEVENTY, ZERO, EOF);
  613.             }

  615.         },

  617.         /** Comments. */
  618.         ZERO("00") {

  620.             /** {@inheritDoc} */
  621.             @Override
  622.             public void parse(final String line, final ParseInfo pi) {

  624.                 // Comment
  625.                 final String comment = line.split(getIdentifier())[1].trim();
  626.                 pi.file.getComments().add(comment);

  628.             }

  630.             /** {@inheritDoc} */
  631.             @Override
  632.             public Stream<LineParser> allowedNext() {
  633.                 return Stream.of(H1, H2, H3, H4, H5, H9,
  634.                                  TEN, TWENTY, THIRTY, FORTY, FIFTY, SIXTY, SEVENTY, ZERO, EOF);
  635.             }

  637.         },

  639.         /** Last record in ephemeris. */
  640.         EOF("99") {

  642.             @Override
  643.             public void parse(final String line, final ParseInfo pi) {
  644.                 pi.done = true;
  645.             }

  647.             /** {@inheritDoc} */
  648.             @Override
  649.             public Stream<LineParser> allowedNext() {
  650.                 return Stream.of(EOF);
  651.             }

  653.         };

  655.         /** Pattern for identifying line. */
  656.         private final Pattern pattern;

  658.         /** Identifier. */
  659.         private final String identifier;

  661.         /** Simple constructor.
  662.          * @param identifier regular expression for identifying line (i.e. first element)
  663.          */
  664.         LineParser(final String identifier) {
  665.             this.identifier = identifier;
  666.             pattern = Pattern.compile(identifier);
  667.         }

  669.         /**
  670.          * Get the regular expression for identifying line.
  671.          * @return the regular expression for identifying line
  672.          */
  673.         public String getIdentifier() {
  674.             return identifier;
  675.         }

  677.         /** Parse a line.
  678.          * @param line line to parse
  679.          * @param pi holder for transient data
  680.          */
  681.         public abstract void parse(String line, ParseInfo pi);

  683.         /** Get the allowed parsers for next line.
  684.          * @return allowed parsers for next line
  685.          */
  686.         public abstract Stream<LineParser> allowedNext();

  688.         /** Check if parser can handle line.
  689.          * @param line line to parse
  690.          * @return true if parser can handle the specified line
  691.          */
  692.         public boolean canHandle(final String line) {
  693.             return pattern.matcher(SEPARATOR.split(line)[0]).matches();
  694.         }

  696.     }

  698. }
Created with JaCoCo 0.8.6.202009150832