UTCTAIHistoryFilesLoader.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.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.ArrayList;
  25. import java.util.List;
  26. import java.util.regex.Matcher;
  27. import java.util.regex.Pattern;

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


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

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

  50.     /** Build a loader for UTC-TAI history file. */
  51.     public UTCTAIHistoryFilesLoader() {
  52.     }

  54.     /** {@inheritDoc} */
  55.     @Override
  56.     public List<OffsetModel> loadOffsets() throws OrekitException {
  57.         final Parser parser = new Parser();
  58.         DataProvidersManager.getInstance().feed(SUPPORTED_NAMES, parser);
  59.         return parser.getOffsets();
  60.     }

  62.     /** Internal class performing the parsing. */
  63.     private static class Parser implements DataLoader {

  65.         /** Regular data lines pattern. */
  66.         private Pattern regularPattern;

  68.         /** Last line pattern pattern. */
  69.         private Pattern lastPattern;

  71.         /** Parsed offsets. */
  72.         private final List<OffsetModel> offsets;

  74.         /** Simple constructor.
  75.          */
  76.         Parser() {

  78.             // the data lines in the UTC time steps data files have the following form:
  79.             // 1966  Jan.  1 - 1968  Feb.  1     4.313 170 0s + (MJD - 39 126) x 0.002 592s
  80.             // 1968  Feb.  1 - 1972  Jan.  1     4.213 170 0s +        ""
  81.             // 1972  Jan.  1 -       Jul.  1    10s
  82.             //       Jul.  1 - 1973  Jan.  1    11s
  83.             // 1973  Jan.  1 - 1974  Jan.  1    12s
  84.             //  ...
  85.             // 2006  Jan.  1.- 2009  Jan.  1    33s
  86.             // 2009  Jan.  1.- 2012  Jul   1    34s
  87.             // 2012  Jul   1 -                  35s

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

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

  95.             // second group: month as a three letters capitalized abbreviation
  96.             final StringBuilder builder = new StringBuilder("\\p{Blank}+(");
  97.             for (final Month month : Month.values()) {
  98.                 builder.append(month.getCapitalizedAbbreviation());
  99.                 builder.append('|');
  100.             }
  101.             builder.delete(builder.length() - 1, builder.length());
  102.             builder.append(")\\.?");
  103.             final String monthField = builder.toString();

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

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

  111.             final String separator   = "\\p{Blank}*-\\p{Blank}+";
  112.             final String finalBlanks = "\\p{Blank}*$";
  113.             regularPattern = Pattern.compile(start + yearField + monthField + dayField +
  114.                                              separator + yearField + monthField + dayField +
  115.                                              offsetField + finalBlanks);
  116.             lastPattern    = Pattern.compile(start + yearField + monthField + dayField +
  117.                                              separator + offsetField + finalBlanks);

  119.             offsets = new ArrayList<OffsetModel>();

  121.         }

  123.         /** Get the parsed offsets.
  124.          * @return parsed offsets
  125.          */
  126.         public List<OffsetModel> getOffsets() {
  127.             return offsets;
  128.         }

  130.         /** {@inheritDoc} */
  131.         public boolean stillAcceptsData() {
  132.             return offsets.isEmpty();
  133.         }

  135.         /** Load UTC-TAI offsets entries read from some file.
  136.          * @param input data input stream
  137.          * @param name name of the file (or zip entry)
  138.          * @exception IOException if data can't be read
  139.          * @exception ParseException if data can't be parsed
  140.          * @exception OrekitException if some data is missing
  141.          * or if some loader specific error occurs
  142.          */
  143.         public void loadData(final InputStream input, final String name)
  144.             throws OrekitException, IOException, ParseException {

  146.             offsets.clear();

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

  151.             // read all file, ignoring not recognized lines
  152.             final String emptyYear = "    ";
  153.             int lineNumber = 0;
  154.             DateComponents lastDate = null;
  155.             int lastLine = 0;
  156.             String previousYear = emptyYear;
  157.             for (String line = reader.readLine(); line != null; line = reader.readLine()) {
  158.                 ++lineNumber;

  160.                 // check matching for regular lines and last line
  161.                 Matcher matcher = regularPattern.matcher(line);
  162.                 if (matcher.matches()) {
  163.                     if (lastLine > 0) {
  164.                         throw new OrekitException(OrekitMessages.UNEXPECTED_DATA_AFTER_LINE_IN_FILE,
  165.                                                   lastLine, name, line);
  166.                     }
  167.                 } else {
  168.                     matcher = lastPattern.matcher(line);
  169.                     if (matcher.matches()) {
  170.                         // this is the last line (there is a start date but no end date)
  171.                         lastLine = lineNumber;
  172.                     }
  173.                 }

  175.                 if (matcher.matches()) {
  176.                     try {
  177.                         // build an entry from the extracted fields

  179.                         String year = matcher.group(1);
  180.                         if (emptyYear.equals(year)) {
  181.                             year = previousYear;
  182.                         }
  183.                         if (lineNumber != lastLine) {
  184.                             if (emptyYear.equals(matcher.group(4))) {
  185.                                 previousYear = year;
  186.                             } else {
  187.                                 previousYear = matcher.group(4);
  188.                             }
  189.                         }
  190.                         final DateComponents leapDay = new DateComponents(Integer.parseInt(year.trim()),
  191.                                                                           Month.parseMonth(matcher.group(2)),
  192.                                                                           Integer.parseInt(matcher.group(3).trim()));

  194.                         final Integer offset = Integer.valueOf(matcher.group(matcher.groupCount()));
  195.                         if ((lastDate != null) && leapDay.compareTo(lastDate) <= 0) {
  196.                             throw new OrekitException(OrekitMessages.NON_CHRONOLOGICAL_DATES_IN_FILE,
  197.                                                       name, lineNumber);
  198.                         }
  199.                         lastDate = leapDay;
  200.                         offsets.add(new OffsetModel(leapDay, offset));

  202.                     } catch (NumberFormatException nfe) {
  203.                         throw new OrekitException(OrekitMessages.UNABLE_TO_PARSE_LINE_IN_FILE,
  204.                                                   lineNumber, name, line);
  205.                     }
  206.                 }
  207.             }

  209.             if (offsets.isEmpty()) {
  210.                 throw new OrekitException(OrekitMessages.NO_ENTRIES_IN_IERS_UTC_TAI_HISTORY_FILE, name);
  211.             }

  213.         }

  215.     }

  217. }
Created with JaCoCo 0.7.9.201702052155