DataProvidersManager.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.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.      * @exception OrekitException if an element of the list does not exist or exists but
  139.      * is neither a directory nor a zip/jar archive
  140.      */
  141.     public void addDefaultProviders() throws OrekitException {

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

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

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

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

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

  170.                 }
  171.             }
  172.         }

  174.     }

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

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

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

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

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

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

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

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

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

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

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

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

  348.         // set up a default configuration if no providers have been set
  349.         if (providers.isEmpty()) {
  350.             addDefaultProviders();
  351.         }

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

  356.         // crawl the data collection
  357.         OrekitException delayedException = null;
  358.         for (final DataProvider provider : providers) {
  359.             try {

  361.                 // try to feed the visitor using the current provider
  362.                 if (provider.feed(supported, monitoredLoader)) {
  363.                     return true;
  364.                 }

  366.             } catch (OrekitException oe) {
  367.                 // remember the last error encountered
  368.                 delayedException = oe;
  369.             }
  370.         }

  372.         if (delayedException != null) {
  373.             throw delayedException;
  374.         }

  376.         return false;

  378.     }

  380.     /** Data loading monitoring wrapper class. */
  381.     private class MonitoringWrapper implements DataLoader {

  383.         /** Wrapped loader. */
  384.         private final DataLoader loader;

  386.         /** Simple constructor.
  387.          * @param loader loader to monitor
  388.          */
  389.         MonitoringWrapper(final DataLoader loader) {
  390.             this.loader = loader;
  391.         }

  393.         /** {@inheritDoc} */
  394.         public boolean stillAcceptsData() {
  395.             // delegate to monitored loader
  396.             return loader.stillAcceptsData();
  397.         }

  399.         /** {@inheritDoc} */
  400.         public void loadData(final InputStream input, final String name)
  401.             throws IOException, ParseException, OrekitException {

  403.             // delegate to monitored loader
  404.             loader.loadData(input, name);

  406.             // monitor the fact new data has been loaded
  407.             loaded.add(name);

  409.         }

  411.     }

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

  422.         /** Unique instance. */
  423.         private static final DataProvidersManager INSTANCE = new DataProvidersManager();

  425.         /** Private constructor.
  426.          * <p>This class is a utility class, it should neither have a public
  427.          * nor a default constructor. This private constructor prevents
  428.          * the compiler from generating one automatically.</p>
  429.          */
  430.         private LazyHolder() {
  431.         }

  433.     }

  435. }
Created with JaCoCo 0.7.9.201702052155