ITRFVersionLoader.java

  1. /* Copyright 2002-2019 CS Systèmes d'Information
  2.  * Licensed to CS Systèmes d'Information (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.frames;

  19. import java.io.BufferedReader;
  20. import java.io.IOException;
  21. import java.io.InputStream;
  22. import java.io.InputStreamReader;
  23. import java.util.ArrayList;
  24. import java.util.List;
  25. import java.util.regex.Matcher;
  26. import java.util.regex.Pattern;

  28. import org.orekit.data.DataLoader;
  29. import org.orekit.data.DataProvidersManager;
  30. import org.orekit.errors.OrekitException;
  31. import org.orekit.errors.OrekitMessages;
  32. import org.orekit.time.DateComponents;

  34. /** Loader for ITRF version configuration file.
  35.  * <p>
  36.  * The ITRF version configuration file specifies
  37.  * the {@link ITRFVersion ITRF versions} that each
  38.  * type of Earth Orientation Parameter file contains
  39.  * for each date. This configuration file is used to
  40.  * interpret {@link EOPC04FilesLoader EOP C04} files,
  41.  * {@link BulletinAFilesLoader Bulletin A} files,
  42.  * {@link BulletinBFilesLoader Bulletin B} files,
  43.  * {@link RapidDataAndPredictionColumnsLoader rapid data
  44.  * and prediction files in columns format} files,
  45.  * {@link RapidDataAndPredictionXMLLoader rapid data
  46.  * and prediction files in XML format} files...
  47.  * </p>
  48.  * <p>This file is an Orekit-specific configuration file.
  49.  * </p>
  50.  * <p>
  51.  * This class is immutable and hence thread-safe
  52.  * </p>
  53.  * @see EOPC04FilesLoader
  54.  * @see BulletinAFilesLoader
  55.  * @see BulletinBFilesLoader
  56.  * @see RapidDataAndPredictionColumnsLoader
  57.  * @see RapidDataAndPredictionXMLLoader
  58.  * @author Luc Maisonobe
  59.  * @since 9.2
  60.  */
  61. class ITRFVersionLoader {

  63.     /** Regular expression for supported files names. */
  64.     public static final String SUPPORTED_NAMES = "itrf-versions.conf";

  66.     /** Regular expression matching anything. */
  67.     private static final String ANYTHING  = ".*";

  69.     /** Default entry to use if no suitable configuration is found. */
  70.     private static final ITRFVersionConfiguration DEFAULT =
  71.                     new ITRFVersionConfiguration(Pattern.compile(ANYTHING), ITRFVersion.ITRF_2014,
  72.                                                  Integer.MIN_VALUE, Integer.MAX_VALUE);

  74.     /** Configuration. */
  75.     private final List<ITRFVersionConfiguration> configurations;

  77.     /** Build a loader for ITRF version configuration file.
  78.      * @param supportedNames regular expression for supported files names
  79.      */
  80.     ITRFVersionLoader(final String supportedNames) {
  81.         this.configurations = new ArrayList<>();
  82.         DataProvidersManager.getInstance().feed(supportedNames, new Parser());
  83.     }

  85.     /** Get the ITRF version configuration defined by a given file at specified date.
  86.      * @param name EOP file name
  87.      * @param mjd date of the EOP in modified Julian day
  88.      * @return configuration valid around specified date in the file
  89.      */
  90.     public ITRFVersionConfiguration getConfiguration(final String name, final int mjd) {

  92.         for (final ITRFVersionConfiguration configuration : configurations) {
  93.             if (configuration.appliesTo(name) && configuration.isValid(mjd)) {
  94.                 // we have found a matching configuration
  95.                 return configuration;
  96.             }
  97.         }

  99.         // no suitable configuration found, use the default value
  100.         return DEFAULT;

  102.     }

  104.     /** Internal class performing the parsing. */
  105.     private class Parser implements DataLoader {

  107.         /** Regular expression matching start of line. */
  108.         private static final String START  = "^";

  110.         /** Regular expression matching a non-blank field (for names regexp). */
  111.         private static final String NON_BLANK_FIELD = "(\\S+)";

  113.         /** Regular expression matching a calendar date. */
  114.         private static final String CALENDAR_DATE  = "\\s+(\\d\\d\\d\\d)-(\\d\\d)-(\\d\\d)";

  116.         /** Regular expression matching a date at infinity. */
  117.         private static final String INFINITY_DATE  = "\\s+-+";

  119.         /** Regular expression matching an ITRF version. */
  120.         private static final String ITRF  = "\\s+(ITRF-\\d\\d(?:\\d\\d)?)";

  122.         /** Regular expression matching end of line. */
  123.         private static final String END  = "$";

  125.         /** {@inheritDoc} */
  126.         public boolean stillAcceptsData() {
  127.             return configurations.isEmpty();
  128.         }

  130.         /** {@inheritDoc} */
  131.         public void loadData(final InputStream input, final String name)
  132.             throws IOException {

  134.             // regular expressions for date lines
  135.             final Pattern patternII = Pattern.compile(START + NON_BLANK_FIELD + INFINITY_DATE + INFINITY_DATE + ITRF + END);
  136.             final Pattern patternID = Pattern.compile(START + NON_BLANK_FIELD + INFINITY_DATE + CALENDAR_DATE + ITRF + END);
  137.             final Pattern patternDI = Pattern.compile(START + NON_BLANK_FIELD + CALENDAR_DATE + INFINITY_DATE + ITRF + END);
  138.             final Pattern patternDD = Pattern.compile(START + NON_BLANK_FIELD + CALENDAR_DATE + CALENDAR_DATE + ITRF + END);

  140.             // set up a reader for line-oriented bulletin A files
  141.             final BufferedReader reader = new BufferedReader(new InputStreamReader(input, "UTF-8"));
  142.             int lineNumber =  0;
  143.             String line = null;

  145.             try {
  146.                 for (line = reader.readLine(); line != null; line = reader.readLine()) {

  148.                     lineNumber++;
  149.                     line = line.trim();
  150.                     if (!(line.startsWith("#") || line.isEmpty())) {
  151.                         Pattern pattern     = null;
  152.                         ITRFVersion version = null;
  153.                         int validityStart   = Integer.MIN_VALUE;
  154.                         int validityEnd     = Integer.MAX_VALUE;
  155.                         final Matcher matcherII = patternII.matcher(line);
  156.                         if (matcherII.matches()) {
  157.                             // both start and end of validity are at infinity
  158.                             // the ITRF version applies throughout history
  159.                             pattern = Pattern.compile(ANYTHING + matcherII.group(1));
  160.                             version = ITRFVersion.getITRFVersion(matcherII.group(2));
  161.                         } else {
  162.                             final Matcher matcherID = patternID.matcher(line);
  163.                             if (matcherID.matches()) {
  164.                                 // both start of validity is at infinity
  165.                                 // the ITRF version applies in the far past
  166.                                 pattern     = Pattern.compile(ANYTHING + matcherID.group(1));
  167.                                 validityEnd = new DateComponents(Integer.parseInt(matcherID.group(2)),
  168.                                                                  Integer.parseInt(matcherID.group(3)),
  169.                                                                  Integer.parseInt(matcherID.group(4))).getMJD();
  170.                                 version     = ITRFVersion.getITRFVersion(matcherID.group(5));
  171.                             } else {
  172.                                 final Matcher matcherDI = patternDI.matcher(line);
  173.                                 if (matcherDI.matches()) {
  174.                                     // both end of validity is at infinity
  175.                                     // the ITRF version applies to the upcoming future
  176.                                     pattern       = Pattern.compile(ANYTHING + matcherDI.group(1));
  177.                                     validityStart = new DateComponents(Integer.parseInt(matcherDI.group(2)),
  178.                                                                        Integer.parseInt(matcherDI.group(3)),
  179.                                                                        Integer.parseInt(matcherDI.group(4))).getMJD();
  180.                                     version       = ITRFVersion.getITRFVersion(matcherDI.group(5));
  181.                                 } else {
  182.                                     final Matcher matcherDD = patternDD.matcher(line);
  183.                                     if (matcherDD.matches()) {
  184.                                         // the ITRF version applies during a limited range
  185.                                         pattern       = Pattern.compile(ANYTHING + matcherDD.group(1));
  186.                                         validityStart = new DateComponents(Integer.parseInt(matcherDD.group(2)),
  187.                                                                            Integer.parseInt(matcherDD.group(3)),
  188.                                                                            Integer.parseInt(matcherDD.group(4))).getMJD();
  189.                                         validityEnd   = new DateComponents(Integer.parseInt(matcherDD.group(5)),
  190.                                                                            Integer.parseInt(matcherDD.group(6)),
  191.                                                                            Integer.parseInt(matcherDD.group(7))).getMJD();
  192.                                         version       = ITRFVersion.getITRFVersion(matcherDD.group(8));
  193.                                     } else {
  194.                                         // data line was not recognized
  195.                                         throw new OrekitException(OrekitMessages.UNABLE_TO_PARSE_LINE_IN_FILE,
  196.                                                                   lineNumber, name, line);
  197.                                     }
  198.                                 }
  199.                             }
  200.                         }

  202.                         // store the parsed entry
  203.                         configurations.add(new ITRFVersionConfiguration(pattern, version, validityStart, validityEnd));

  205.                     }

  207.                 }
  208.             } catch (IllegalArgumentException e) {
  209.                 throw new OrekitException(e,
  210.                                           OrekitMessages.UNABLE_TO_PARSE_LINE_IN_FILE,
  211.                                           lineNumber, name, line);
  212.             }

  214.         }

  216.     }

  218.     /** ITRF version configuration entry. */
  219.     public static class ITRFVersionConfiguration {

  221.         /** File names to which this configuration applies. */
  222.         private final Pattern pattern;

  224.         /** ITRF version. */
  225.         private final ITRFVersion version;

  227.         /** Start of validity. */
  228.         private final int validityStart;

  230.         /** End of validity. */
  231.         private final int validityEnd;

  233.         /** Simple constructor.
  234.          * @param pattern file names to which this configuration applies
  235.          * @param version ITRF version
  236.          * @param validityStart start of validity (included)
  237.          * @param validityEnd end of validity (excluded)
  238.          */
  239.         ITRFVersionConfiguration(final Pattern pattern,
  240.                                  final ITRFVersion version,
  241.                                  final int validityStart,
  242.                                  final int validityEnd) {
  243.             this.pattern       = pattern;
  244.             this.version       = version;
  245.             this.validityStart = validityStart;
  246.             this.validityEnd   = validityEnd;
  247.         }

  249.         /** Check if this entry applies to a file name.
  250.          * @param name file name to check
  251.          * @return true if the configuration applies to the specified file
  252.          */
  253.         boolean appliesTo(final String name) {
  254.             return pattern.matcher(name).matches();
  255.         }

  257.         /** Get ITRF version.
  258.          * @return ITRF version
  259.          */
  260.         public ITRFVersion getVersion() {
  261.             return version;
  262.         }

  264.         /** Check if configuration entry is valid for a date.
  265.          * @param mjd date to check in modified Julian day
  266.          * @return true if entry is valid for the specified date
  267.          */
  268.         public boolean isValid(final int mjd) {
  269.             return validityStart <= mjd && mjd < validityEnd;
  270.         }

  272.     }

  274. }
Created with JaCoCo 0.8.2.201808211720