DataProvidersManager.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.data;

  19. import java.io.File;
  20. import java.io.IOException;
  21. import java.io.InputStream;
  22. import java.text.ParseException;
  23. import java.util.ArrayList;
  24. import java.util.Collections;
  25. import java.util.Iterator;
  26. import java.util.LinkedHashSet;
  27. import java.util.List;
  28. import java.util.Set;
  29. import java.util.regex.Pattern;

  31. import org.orekit.errors.OrekitException;
  32. import org.orekit.errors.OrekitMessages;

  34. /** Singleton class managing all supported {@link DataProvider data providers}.

  36.  * <p>
  37.  * This class is the single point of access for all data loading features. It
  38.  * is used for example to load Earth Orientation Parameters used by IERS frames,
  39.  * to load UTC leap seconds used by time scales, to load planetary ephemerides ...
  40.  *
  41.  * <p>
  42.  * It is user-customizable: users can add their own data providers at will. This
  43.  * allows them for example to use a database or an existing data loading library
  44.  * in order to embed an Orekit enabled application in a global system with its
  45.  * own data handling mechanisms. There is no upper limitation on the number of
  46.  * providers, but often each application will use only a few.
  47.  * </p>
  48.  *
  49.  * <p>
  50.  * If the list of providers is empty when attempting to {@link #feed(String, DataLoader)
  51.  * feed} a file loader, the {@link #addDefaultProviders()} method is called
  52.  * automatically to set up a default configuration. This default configuration
  53.  * contains one {@link DataProvider data provider} for each component of the
  54.  * path-like list specified by the java property <code>orekit.data.path</code>.
  55.  * See the {@link #feed(String, DataLoader) feed} method documentation for further
  56.  * details. The default providers configuration is <em>not</em> set up if the list
  57.  * is not empty. If users want to have both the default providers and additional
  58.  * providers, they must call explicitly the {@link #addDefaultProviders()} method.
  59.  * </p>
  60.  *
  61.  * <p>
  62.  * The default configuration uses a predefined set of {@link DataFilter data filters}
  63.  * that already handled gzip-compressed files (recognized by the {@code .gz} suffix)
  64.  * and Unix-compressed files (recognized by the {@code .Z} suffix).
  65.  * Users can {@link #addFilter(DataFilter) add} custom filters for handling specific
  66.  * types of filters (decompression, deciphering...).
  67.  * </p>
  68.  *
  69.  * @author Luc Maisonobe
  70.  * @see DirectoryCrawler
  71.  * @see ClasspathCrawler
  72.  */
  73. public class DataProvidersManager {

  75.     /** Name of the property defining the root directories or zip/jar files path for default configuration. */
  76.     public static final String OREKIT_DATA_PATH = "orekit.data.path";

  78.     /** Supported data providers. */
  79.     private final List<DataProvider> providers;

  81.     /** Supported filters.
  82.      * @since 9.2
  83.      */
  84.     private final List<DataFilter> filters;

  86.     /** Number of predefined filters. */
  87.     private final int predefinedFilters;

  89.     /** Loaded data. */
  90.     private final Set<String> loaded;

  92.     /** Build an instance with default configuration.
  93.      * <p>
  94.      * This is a singleton, so the constructor is private.
  95.      * </p>
  96.      */
  97.     private DataProvidersManager() {
  98.         providers = new ArrayList<DataProvider>();
  99.         filters   = new ArrayList<>();
  100.         loaded    = new LinkedHashSet<String>();

  102.         // set up predefined filters
  103.         addFilter(new GzipFilter());
  104.         addFilter(new UnixCompressFilter());

  106.         predefinedFilters = filters.size();

  108.     }

  110.     /** Get the unique instance.
  111.      * @return unique instance of the manager.
  112.      */
  113.     public static DataProvidersManager getInstance() {
  114.         return LazyHolder.INSTANCE;
  115.     }

  117.     /** Add the default providers configuration.
  118.      * <p>
  119.      * The default configuration contains one {@link DataProvider data provider}
  120.      * for each component of the path-like list specified by the java property
  121.      * <code>orekit.data.path</code>.
  122.      * </p>
  123.      * <p>
  124.      * If the property is not set or is null, no data will be available to the library
  125.      * (for example no pole corrections will be applied and only predefined UTC steps
  126.      * will be taken into account). No errors will be triggered in this case.
  127.      * </p>
  128.      * <p>
  129.      * If the property is set, it must contains a list of existing directories or zip/jar
  130.      * archives. One {@link DirectoryCrawler} instance will be set up for each
  131.      * directory and one {@link ZipJarCrawler} instance (configured to look for the
  132.      * archive in the filesystem) will be set up for each zip/jar archive. The list
  133.      * elements in the java property are separated using the standard path separator for
  134.      * the operating system as returned by {@link System#getProperty(String)
  135.      * System.getProperty("path.separator")}. This standard path separator is ":" on
  136.      * Linux and Unix type systems and ";" on Windows types systems.
  137.      * </p>
  138.      */
  139.     public void addDefaultProviders() {

  141.         // get the path containing all components
  142.         final String path = System.getProperty(OREKIT_DATA_PATH);
  143.         if ((path != null) && !"".equals(path)) {

  145.             // extract the various components
  146.             for (final String name : path.split(System.getProperty("path.separator"))) {
  147.                 if (!"".equals(name)) {

  149.                     final File file = new File(name);

  151.                     // check component
  152.                     if (!file.exists()) {
  153.                         if (DataProvider.ZIP_ARCHIVE_PATTERN.matcher(name).matches()) {
  154.                             throw new OrekitException(OrekitMessages.UNABLE_TO_FIND_FILE, name);
  155.                         } else {
  156.                             throw new OrekitException(OrekitMessages.DATA_ROOT_DIRECTORY_DOES_NOT_EXIST, name);
  157.                         }
  158.                     }

  160.                     if (file.isDirectory()) {
  161.                         addProvider(new DirectoryCrawler(file));
  162.                     } else if (DataProvider.ZIP_ARCHIVE_PATTERN.matcher(name).matches()) {
  163.                         addProvider(new ZipJarCrawler(file));
  164.                     } else {
  165.                         throw new OrekitException(OrekitMessages.NEITHER_DIRECTORY_NOR_ZIP_OR_JAR, name);
  166.                     }

  168.                 }
  169.             }
  170.         }

  172.     }

  174.     /** Add a data provider to the supported list.
  175.      * @param provider data provider to add
  176.      * @see #removeProvider(DataProvider)
  177.      * @see #clearProviders()
  178.      * @see #isSupported(DataProvider)
  179.      * @see #getProviders()
  180.      */
  181.     public void addProvider(final DataProvider provider) {
  182.         providers.add(provider);
  183.     }

  185.     /** Remove one provider.
  186.      * @param provider provider instance to remove
  187.      * @return instance removed (null if the provider was not already present)
  188.      * @see #addProvider(DataProvider)
  189.      * @see #clearProviders()
  190.      * @see #isSupported(DataProvider)
  191.      * @see #getProviders()
  192.      * @since 5.1
  193.      */
  194.     public DataProvider removeProvider(final DataProvider provider) {
  195.         for (final Iterator<DataProvider> iterator = providers.iterator(); iterator.hasNext();) {
  196.             final DataProvider current = iterator.next();
  197.             if (current == provider) {
  198.                 iterator.remove();
  199.                 return provider;
  200.             }
  201.         }
  202.         return null;
  203.     }

  205.     /** Remove all data providers.
  206.      * @see #addProvider(DataProvider)
  207.      * @see #removeProvider(DataProvider)
  208.      * @see #isSupported(DataProvider)
  209.      * @see #getProviders()
  210.      */
  211.     public void clearProviders() {
  212.         providers.clear();
  213.     }

  215.     /** Add a data filter.
  216.      * @param filter filter to add
  217.      * @see #applyAllFilters(NamedData)
  218.      * @see #clearFilters()
  219.      * @since 9.2
  220.      */
  221.     public void addFilter(final DataFilter filter) {
  222.         filters.add(filter);
  223.     }

  225.     /** Remove all data filters, except the predefined ones.
  226.      * @see #addFilter(DataFilter)
  227.      * @since 9.2
  228.      */
  229.     public void clearFilters() {
  230.         for (int i = filters.size() - 1; i >= predefinedFilters; --i) {
  231.             filters.remove(i);
  232.         }
  233.     }

  235.     /** Apply all the relevant data filters, taking care of layers.
  236.      * <p>
  237.      * If several filters can be applied, they will all be applied
  238.      * as a stack, even recursively if required. This means that if
  239.      * filter A applies to files with names of the form base.ext.a
  240.      * and filter B applies to files with names of the form base.ext.b,
  241.      * then providing base.ext.a.b.a will result in filter A being
  242.      * applied on top of filter B which itself is applied on top of
  243.      * another instance of filter A.
  244.      * </p>
  245.      * @param original original named data
  246.      * @return fully filtered named data
  247.      * @exception IOException if some data stream cannot be filtered
  248.      * @see #addFilter(DataFilter)
  249.      * @see #clearFilters()
  250.      * @since 9.2
  251.      */
  252.     public NamedData applyAllFilters(final NamedData original)
  253.         throws IOException {
  254.         NamedData top = original;
  255.         for (boolean filtering = true; filtering;) {
  256.             filtering = false;
  257.             for (final DataFilter filter : filters) {
  258.                 final NamedData filtered = filter.filter(top);
  259.                 if (filtered != top) {
  260.                     // the filter has been applied, we need to restart the loop
  261.                     top       = filtered;
  262.                     filtering = true;
  263.                     break;
  264.                 }
  265.             }
  266.         }
  267.         return top;
  268.     }

  270.     /** Check if some provider is supported.
  271.      * @param provider provider to check
  272.      * @return true if the specified provider instance is already in the supported list
  273.      * @see #addProvider(DataProvider)
  274.      * @see #removeProvider(DataProvider)
  275.      * @see #clearProviders()
  276.      * @see #getProviders()
  277.      * @since 5.1
  278.      */
  279.     public boolean isSupported(final DataProvider provider) {
  280.         for (final DataProvider current : providers) {
  281.             if (current == provider) {
  282.                 return true;
  283.             }
  284.         }
  285.         return false;
  286.     }

  288.     /** Get an unmodifiable view of the list of supported providers.
  289.      * @return unmodifiable view of the list of supported providers
  290.      * @see #addProvider(DataProvider)
  291.      * @see #removeProvider(DataProvider)
  292.      * @see #clearProviders()
  293.      * @see #isSupported(DataProvider)
  294.      */
  295.     public List<DataProvider> getProviders() {
  296.         return Collections.unmodifiableList(providers);
  297.     }

  299.     /** Get an unmodifiable view of the set of data file names that have been loaded.
  300.      * <p>
  301.      * The names returned are exactly the ones that were given to the {@link
  302.      * DataLoader#loadData(InputStream, String) DataLoader.loadData} method.
  303.      * </p>
  304.      * @return unmodifiable view of the set of data file names that have been loaded
  305.      * @see #feed(String, DataLoader)
  306.      * @see #clearLoadedDataNames()
  307.      */
  308.     public Set<String> getLoadedDataNames() {
  309.         return Collections.unmodifiableSet(loaded);
  310.     }

  312.     /** Clear the set of data file names that have been loaded.
  313.      * @see #getLoadedDataNames()
  314.      */
  315.     public void clearLoadedDataNames() {
  316.         loaded.clear();
  317.     }

  319.     /** Feed a data file loader by browsing all data providers.
  320.      * <p>
  321.      * If this method is called with an empty list of providers, a default
  322.      * providers configuration is set up. This default configuration contains
  323.      * only one {@link DataProvider data provider}: a {@link DirectoryCrawler}
  324.      * instance that loads data from files located somewhere in a directory hierarchy.
  325.      * This default provider is <em>not</em> added if the list is not empty. If users
  326.      * want to have both the default provider and other providers, they must add it
  327.      * explicitly.
  328.      * </p>
  329.      * <p>
  330.      * The providers are used in the order in which they were {@link #addProvider(DataProvider)
  331.      * added}. As soon as one provider is able to feed the data loader, the loop is
  332.      * stopped. If no provider is able to feed the data loader, then the last error
  333.      * triggered is thrown.
  334.      * </p>
  335.      * @param supportedNames regular expression for file names supported by the visitor
  336.      * @param loader data loader to use
  337.      * @return true if some data has been loaded
  338.      */
  339.     public boolean feed(final String supportedNames, final DataLoader loader) {

  341.         final Pattern supported = Pattern.compile(supportedNames);

  343.         // set up a default configuration if no providers have been set
  344.         if (providers.isEmpty()) {
  345.             addDefaultProviders();
  346.         }

  348.         // monitor the data that the loader will load
  349.         final DataLoader monitoredLoader = new MonitoringWrapper(loader);

  351.         // crawl the data collection
  352.         OrekitException delayedException = null;
  353.         for (final DataProvider provider : providers) {
  354.             try {

  356.                 // try to feed the visitor using the current provider
  357.                 if (provider.feed(supported, monitoredLoader)) {
  358.                     return true;
  359.                 }

  361.             } catch (OrekitException oe) {
  362.                 // remember the last error encountered
  363.                 delayedException = oe;
  364.             }
  365.         }

  367.         if (delayedException != null) {
  368.             throw delayedException;
  369.         }

  371.         return false;

  373.     }

  375.     /** Data loading monitoring wrapper class. */
  376.     private class MonitoringWrapper implements DataLoader {

  378.         /** Wrapped loader. */
  379.         private final DataLoader loader;

  381.         /** Simple constructor.
  382.          * @param loader loader to monitor
  383.          */
  384.         MonitoringWrapper(final DataLoader loader) {
  385.             this.loader = loader;
  386.         }

  388.         /** {@inheritDoc} */
  389.         public boolean stillAcceptsData() {
  390.             // delegate to monitored loader
  391.             return loader.stillAcceptsData();
  392.         }

  394.         /** {@inheritDoc} */
  395.         public void loadData(final InputStream input, final String name)
  396.             throws IOException, ParseException, OrekitException {

  398.             // delegate to monitored loader
  399.             loader.loadData(input, name);

  401.             // monitor the fact new data has been loaded
  402.             loaded.add(name);

  404.         }

  406.     }

  408.     /** Holder for the manager singleton.
  409.      * <p>
  410.      * We use the Initialization on demand holder idiom to store
  411.      * the singletons, as it is both thread-safe, efficient (no
  412.      * synchronization) and works with all versions of java.
  413.      * </p>
  414.      */
  415.     private static class LazyHolder {

  417.         /** Unique instance. */
  418.         private static final DataProvidersManager INSTANCE = new DataProvidersManager();

  420.         /** Private constructor.
  421.          * <p>This class is a utility class, it should neither have a public
  422.          * nor a default constructor. This private constructor prevents
  423.          * the compiler from generating one automatically.</p>
  424.          */
  425.         private LazyHolder() {
  426.         }

  428.     }

  430. }
Created with JaCoCo 0.8.2.201808211720