UTCTAIHistoryFilesLoader.java

  1. /* Copyright 2002-2013 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.time;

  19. import java.io.BufferedReader;
  20. import java.io.IOException;
  21. import java.io.InputStream;
  22. import java.io.InputStreamReader;
  23. import java.text.ParseException;
  24. import java.util.SortedMap;
  25. import java.util.TreeMap;
  26. import java.util.regex.Matcher;
  27. import java.util.regex.Pattern;

  29. import org.orekit.errors.OrekitException;
  30. import org.orekit.errors.OrekitMessages;


  33. /** Loader for UTC versus TAI history files.
  34.  * <p>UTC versus TAI history files contain {@link UTCTAIOffset
  35.  * leap seconds} data since.</p>
  36.  * <p>The UTC versus TAI history files are recognized thanks to their
  37.  * base names, which must match the pattern <code>UTC-TAI.history</code>
  38.  * (or <code>UTC-TAI.history.gz</code> for gzip-compressed files)</p>
  39.  * <p>Only one history file must be present in the IERS directories
  40.  * hierarchy.</p>
  41.  * @author Luc Maisonobe
  42.  */
  43. class UTCTAIHistoryFilesLoader implements UTCTAILoader {

  45.     /** Supported files name pattern. */
  46.     private static final String SUPPORTED_NAMES = "^UTC-TAI\\.history$";

  48.     /** Regular data lines pattern. */
  49.     private Pattern regularPattern;

  51.     /** Last line pattern pattern. */
  52.     private Pattern lastPattern;

  54.     /** Time scales offsets. */
  55.     private SortedMap<DateComponents, Integer> entries;

  57.     /** Build a loader for UTC-TAI history file. */
  58.     public UTCTAIHistoryFilesLoader() {

  60.         // the data lines in the UTC time steps data files have the following form:
  61.         // 1966  Jan.  1 - 1968  Feb.  1     4.313 170 0s + (MJD - 39 126) x 0.002 592s
  62.         // 1968  Feb.  1 - 1972  Jan.  1     4.213 170 0s +        ""
  63.         // 1972  Jan.  1 -       Jul.  1    10s
  64.         //       Jul.  1 - 1973  Jan.  1    11s
  65.         // 1973  Jan.  1 - 1974  Jan.  1    12s
  66.         //  ...
  67.         // 2006  Jan.  1.- 2009  Jan.  1    33s
  68.         // 2009  Jan.  1.- 2012  Jul   1    34s
  69.         // 2012  Jul   1 -                  35s

  71.         // we ignore the non-constant and non integer offsets before 1972-01-01
  72.         final String start = "^";

  74.         // year group
  75.         final String yearField = "\\p{Blank}*((?:\\p{Digit}\\p{Digit}\\p{Digit}\\p{Digit})|(?:    ))";

  77.         // second group: month as a three letters capitalized abbreviation
  78.         final StringBuilder builder = new StringBuilder("\\p{Blank}+(");
  79.         for (final Month month : Month.values()) {
  80.             builder.append(month.getCapitalizedAbbreviation());
  81.             builder.append('|');
  82.         }
  83.         builder.delete(builder.length() - 1, builder.length());
  84.         builder.append(")\\.?");
  85.         final String monthField = builder.toString();

  87.         // day group
  88.         final String dayField = "\\p{Blank}+([ 0-9]+)\\.?";

  90.         // offset group
  91.         final String offsetField = "\\p{Blank}+(\\p{Digit}+)s";

  93.         final String separator   = "\\p{Blank}*-\\p{Blank}+";
  94.         final String finalBlanks = "\\p{Blank}*$";
  95.         regularPattern = Pattern.compile(start + yearField + monthField + dayField +
  96.                                          separator + yearField + monthField + dayField +
  97.                                          offsetField + finalBlanks);
  98.         lastPattern    = Pattern.compile(start + yearField + monthField + dayField +
  99.                                          separator + offsetField + finalBlanks);

  101.         entries = new TreeMap<DateComponents, Integer>();

  103.     }

  105.     /** Get the regular expression for supported files names.
  106.      * @return regular expression for supported files names
  107.      */
  108.     public String getSupportedNames() {
  109.         return SUPPORTED_NAMES;
  110.     }

  112.     /** Load stored UTC-TAI offsets entries.
  113.      * @return sorted UTC-TAI offsets entries (may be empty if no data file is available)
  114.      */
  115.     public SortedMap<DateComponents, Integer> loadTimeSteps() {
  116.         return entries;
  117.     }

  119.     /** {@inheritDoc} */
  120.     public boolean stillAcceptsData() {
  121.         return (entries == null) || entries.isEmpty();
  122.     }

  124.     /** Load UTC-TAI offsets entries read from some file.
  125.      * <p>The time steps are extracted from some <code>UTC-TAI.history[.gz]</code>
  126.      * file. Since entries are stored in a {@link java.util.SortedMap SortedMap},
  127.      * they are chronologically sorted and only one entry remains for a given date.</p>
  128.      * @param input data input stream
  129.      * @param name name of the file (or zip entry)
  130.      * @exception IOException if data can't be read
  131.      * @exception ParseException if data can't be parsed
  132.      * @exception OrekitException if some data is missing
  133.      * or if some loader specific error occurs
  134.      */
  135.     public void loadData(final InputStream input, final String name)
  136.         throws OrekitException, IOException, ParseException {

  138.         entries.clear();

  140.         // set up a reader for line-oriented file
  141.         final BufferedReader reader = new BufferedReader(new InputStreamReader(input, "UTF-8"));

  143.         // read all file, ignoring not recognized lines
  144.         boolean foundEntries = false;
  145.         final String emptyYear = "    ";
  146.         int lineNumber = 0;
  147.         DateComponents lastDate = null;
  148.         int lastLine = 0;
  149.         String previousYear = emptyYear;
  150.         for (String line = reader.readLine(); line != null; line = reader.readLine()) {
  151.             ++lineNumber;

  153.             // check matching for regular lines and last line
  154.             Matcher matcher = regularPattern.matcher(line);
  155.             if (matcher.matches()) {
  156.                 if (lastLine > 0) {
  157.                     throw new OrekitException(OrekitMessages.UNEXPECTED_DATA_AFTER_LINE_IN_FILE,
  158.                                               lastLine, name, line);
  159.                 }
  160.             } else {
  161.                 matcher = lastPattern.matcher(line);
  162.                 if (matcher.matches()) {
  163.                     // this is the last line (there is a start date but no end date)
  164.                     lastLine = lineNumber;
  165.                 }
  166.             }

  168.             if (matcher.matches()) {
  169.                 try {
  170.                     // build an entry from the extracted fields

  172.                     String year = matcher.group(1);
  173.                     if (emptyYear.equals(year)) {
  174.                         year = previousYear;
  175.                     }
  176.                     if (lineNumber != lastLine) {
  177.                         if (emptyYear.equals(matcher.group(4))) {
  178.                             previousYear = year;
  179.                         } else {
  180.                             previousYear = matcher.group(4);
  181.                         }
  182.                     }
  183.                     final DateComponents leapDay = new DateComponents(Integer.parseInt(year.trim()),
  184.                                                                       Month.parseMonth(matcher.group(2)),
  185.                                                                       Integer.parseInt(matcher.group(3).trim()));

  187.                     final Integer offset = Integer.valueOf(matcher.group(matcher.groupCount()));
  188.                     if ((lastDate != null) && leapDay.compareTo(lastDate) <= 0) {
  189.                         throw new OrekitException(OrekitMessages.NON_CHRONOLOGICAL_DATES_IN_FILE,
  190.                                                   name, lineNumber);
  191.                     }
  192.                     lastDate = leapDay;
  193.                     foundEntries = true;
  194.                     entries.put(leapDay, offset);

  196.                 } catch (NumberFormatException nfe) {
  197.                     throw new OrekitException(OrekitMessages.UNABLE_TO_PARSE_LINE_IN_FILE,
  198.                                               lineNumber, name, line);
  199.                 }
  200.             }
  201.         }

  203.         if (!foundEntries) {
  204.             throw new OrekitException(OrekitMessages.NO_ENTRIES_IN_IERS_UTC_TAI_HISTORY_FILE, name);
  205.         }

  207.     }

  209. }
Created with JaCoCo 0.6.3.201306030806