ITRFVersionLoader.java

  1. /* Copyright 2002-2018 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.      * @exception OrekitException if configuration file cannot be loaded
  80.      */
  81.     ITRFVersionLoader(final String supportedNames) throws OrekitException {
  82.         this.configurations = new ArrayList<>();
  83.         DataProvidersManager.getInstance().feed(supportedNames, new Parser());
  84.     }

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

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

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

  103.     }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  206.                     }

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

  215.         }

  217.     }

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

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

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

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

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

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

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

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

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

  273.     }

  275. }
Created with JaCoCo 0.7.9.201702052155