DataProvidersManager.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.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.  * <p>
  41.  *
  42.  * </p>
  43.  * It is user-customizable: users can add their own data providers at will. This
  44.  * allows them for example to use a database or an existing data loading library
  45.  * in order to embed an Orekit enabled application in a global system with its
  46.  * own data handling mechanisms. There is no upper limitation on the number of
  47.  * providers, but often each application will use only a few.
  48.  * </p>
  49.  *
  50.  * <p>
  51.  * If the list of providers is empty when attempting to {@link #feed(String, DataLoader)
  52.  * feed} a file loader, the {@link #addDefaultProviders()} method is called
  53.  * automatically to set up a default configuration. This default configuration
  54.  * contains one {@link DataProvider data provider} for each component of the
  55.  * path-like list specified by the java property <code>orekit.data.path</code>.
  56.  * See the {@link #feed(String, DataLoader) feed} method documentation for further
  57.  * details. The default providers configuration is <em>not</em> set up if the list
  58.  * is not empty. If users want to have both the default providers and additional
  59.  * providers, they must call explicitly the {@link #addDefaultProviders()} method.
  60.  * </p>
  61.  *
  62.  * @author Luc Maisonobe
  63.  * @see DirectoryCrawler
  64.  * @see ClasspathCrawler
  65.  */
  66. public class DataProvidersManager {

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

  71.     /** Supported data providers. */
  72.     private final List<DataProvider> providers;

  74.     /** Loaded data. */
  75.     private final Set<String> loaded;

  77.     /** Build an instance with default configuration.
  78.      * <p>
  79.      * This is a singleton, so the constructor is private.
  80.      * </p>
  81.      */
  82.     private DataProvidersManager() {
  83.         providers = new ArrayList<DataProvider>();
  84.         loaded    = new LinkedHashSet<String>();
  85.     }

  87.     /** Get the unique instance.
  88.      * @return unique instance of the manager.
  89.      */
  90.     public static DataProvidersManager getInstance() {
  91.         return LazyHolder.INSTANCE;
  92.     }

  94.     /** Add the default providers configuration.
  95.      * <p>
  96.      * The default configuration contains one {@link DataProvider data provider}
  97.      * for each component of the path-like list specified by the java property
  98.      * <code>orekit.data.path</code>.
  99.      * </p>
  100.      * <p>
  101.      * If the property is not set or is null, no data will be available to the library
  102.      * (for example no pole corrections will be applied and only predefined UTC steps
  103.      * will be taken into account). No errors will be triggered in this case.
  104.      * </p>
  105.      * <p>
  106.      * If the property is set, it must contains a list of existing directories or zip/jar
  107.      * archives. One {@link DirectoryCrawler} instance will be set up for each
  108.      * directory and one {@link ZipJarCrawler} instance (configured to look for the
  109.      * archive in the filesystem) will be set up for each zip/jar archive. The list
  110.      * elements in the java property are separated using the standard path separator for
  111.      * the operating system as returned by {@link System#getProperty(String)
  112.      * System.getProperty("path.separator")}. This standard path separator is ":" on
  113.      * Linux and Unix type systems and ";" on Windows types systems.
  114.      * </p>
  115.      * @exception OrekitException if an element of the list does not exist or exists but
  116.      * is neither a directory nor a zip/jar archive
  117.      */
  118.     public void addDefaultProviders() throws OrekitException {

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

  124.             // extract the various components
  125.             for (final String name : path.split(System.getProperty("path.separator"))) {
  126.                 if (!"".equals(name)) {

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

  130.                     // check component
  131.                     if (!file.exists()) {
  132.                         if (DataProvider.ZIP_ARCHIVE_PATTERN.matcher(name).matches()) {
  133.                             throw new OrekitException(OrekitMessages.UNABLE_TO_FIND_FILE, name);
  134.                         } else {
  135.                             throw new OrekitException(OrekitMessages.DATA_ROOT_DIRECTORY_DOES_NOT_EXIST, name);
  136.                         }
  137.                     }

  139.                     if (file.isDirectory()) {
  140.                         addProvider(new DirectoryCrawler(file));
  141.                     } else if (DataProvider.ZIP_ARCHIVE_PATTERN.matcher(name).matches()) {
  142.                         addProvider(new ZipJarCrawler(file));
  143.                     } else {
  144.                         throw new OrekitException(OrekitMessages.NEITHER_DIRECTORY_NOR_ZIP_OR_JAR, name);
  145.                     }

  147.                 }
  148.             }
  149.         }

  151.     }

  153.     /** Add a data provider to the supported list.
  154.      * @param provider data provider to add
  155.      * @see #removeProvider(Class)
  156.      * @see #clearProviders()
  157.      * @see #isSupported(Class)
  158.      * @see #getProviders()
  159.      */
  160.     public void addProvider(final DataProvider provider) {
  161.         providers.add(provider);
  162.     }

  164.     /** Remove one provider.
  165.      * <p>
  166.      * The first supported provider extending the specified class (or implementing
  167.      * the interface) is removed and returned. For example, removing the default
  168.      * provider that loads data from files located somewhere in a directory hierarchy
  169.      * can be done by calling:
  170.      * <pre>
  171.      *   DataProvidersManager.getInstance().remove(DataDirectoryCrawler.class);
  172.      * </pre>
  173.      * </p>
  174.      * @param providerClass class (or one of the superclass's) of the provider to remove
  175.      * @return instance removed (null if no provider of the given class was supported)
  176.      * @see #addProvider(DataProvider)
  177.      * @see #clearProviders()
  178.      * @see #isSupported(Class)
  179.      * @see #getProviders()
  180.      * @deprecated as of 6.0, replaced by {@link #removeProvider(DataProvider)}
  181.      */
  182.     @Deprecated
  183.     public DataProvider removeProvider(final Class<? extends DataProvider> providerClass) {
  184.         for (final DataProvider provider : providers) {
  185.             if (providerClass.isInstance(provider)) {
  186.                 return removeProvider(provider);
  187.             }
  188.         }
  189.         return null;
  190.     }

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

  212.     /** Remove all data providers.
  213.      * @see #addProvider(DataProvider)
  214.      * @see #removeProvider(Class)
  215.      * @see #isSupported(Class)
  216.      * @see #getProviders()
  217.      */
  218.     public void clearProviders() {
  219.         providers.clear();
  220.     }

  222.     /** Check if some type of provider is supported.
  223.      * @param providerClass class (or one of the superclass's) of the provider to check
  224.      * @return true if one provider of the given class is already in the supported list
  225.      * @see #addProvider(DataProvider)
  226.      * @see #removeProvider(Class)
  227.      * @see #clearProviders()
  228.      * @see #getProviders()
  229.      * @deprecated as of 6.0, replaced by {@link #isSupported(DataProvider)}
  230.      */
  231.     @Deprecated
  232.     public boolean isSupported(final Class<? extends DataProvider> providerClass) {
  233.         for (final Iterator<DataProvider> iterator = providers.iterator(); iterator.hasNext();) {
  234.             final DataProvider provider = iterator.next();
  235.             if (providerClass.isInstance(provider)) {
  236.                 return true;
  237.             }
  238.         }
  239.         return false;
  240.     }

  242.     /** Check if some provider is supported.
  243.      * @param provider provider to check
  244.      * @return true if the specified provider instane is already in the supported list
  245.      * @see #addProvider(DataProvider)
  246.      * @see #removeProvider(DataProvider)
  247.      * @see #clearProviders()
  248.      * @see #getProviders()
  249.      * @since 5.1
  250.      */
  251.     public boolean isSupported(final DataProvider provider) {
  252.         for (final DataProvider current : providers) {
  253.             if (current == provider) {
  254.                 return true;
  255.             }
  256.         }
  257.         return false;
  258.     }

  260.     /** Get an unmodifiable view of the list of supported providers.
  261.      * @return unmodifiable view of the list of supported providers
  262.      * @see #addProvider(DataProvider)
  263.      * @see #removeProvider(Class)
  264.      * @see #clearProviders()
  265.      * @see #isSupported(Class)
  266.      */
  267.     public List<DataProvider> getProviders() {
  268.         return Collections.unmodifiableList(providers);
  269.     }

  271.     /** Get an unmodifiable view of the set of data file names that have been loaded.
  272.      * <p>
  273.      * The names returned are exactly the ones that were given to the {@link
  274.      * DataLoader#loadData(InputStream, String) DataLoader.loadData} method.
  275.      * </p>
  276.      * @return unmodifiable view of the set of data file names that have been loaded
  277.      * @see #feed(String, DataLoader)
  278.      * @see #clearLoadedDataNames()
  279.      */
  280.     public Set<String> getLoadedDataNames() {
  281.         return Collections.unmodifiableSet(loaded);
  282.     }

  284.     /** Clear the set of data file names that have been loaded.
  285.      * @see #getLoadedDataNames()
  286.      */
  287.     public void clearLoadedDataNames() {
  288.         loaded.clear();
  289.     }

  291.     /** Feed a data file loader by browsing all data providers.
  292.      * <p>
  293.      * If this method is called with an empty list of providers, a default
  294.      * providers configuration is set up. This default configuration contains
  295.      * only one {@link DataProvider data provider}: a {@link DirectoryCrawler}
  296.      * instance that loads data from files located somewhere in a directory hierarchy.
  297.      * This default provider is <em>not</em> added if the list is not empty. If users
  298.      * want to have both the default provider and other providers, they must add it
  299.      * explicitly.
  300.      * </p>
  301.      * <p>
  302.      * The providers are used in the order in which they were {@link #addProvider(DataProvider)
  303.      * added}. As soon as one provider is able to feed the data loader, the loop is
  304.      * stopped. If no provider is able to feed the data loader, then the last error
  305.      * triggered is thrown.
  306.      * </p>
  307.      * @param supportedNames regular expression for file names supported by the visitor
  308.      * @param loader data loader to use
  309.      * @return true if some data has been loaded
  310.      * @exception OrekitException if the data loader cannot be fed (read error ...)
  311.      * or if the default configuration cannot be set up
  312.      */
  313.     public boolean feed(final String supportedNames, final DataLoader loader)
  314.         throws OrekitException {

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

  318.         // set up a default configuration if no providers have been set
  319.         if (providers.isEmpty()) {
  320.             addDefaultProviders();
  321.         }

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

  326.         // crawl the data collection
  327.         OrekitException delayedException = null;
  328.         for (final DataProvider provider : providers) {
  329.             try {

  331.                 // try to feed the visitor using the current provider
  332.                 if (provider.feed(supported, monitoredLoader)) {
  333.                     return true;
  334.                 }

  336.             } catch (OrekitException oe) {
  337.                 // remember the last error encountered
  338.                 delayedException = oe;
  339.             }
  340.         }

  342.         if (delayedException != null) {
  343.             throw delayedException;
  344.         }

  346.         return false;

  348.     }

  350.     /** Data loading monitoring wrapper class. */
  351.     private class MonitoringWrapper implements DataLoader {

  353.         /** Wrapped loader. */
  354.         private final DataLoader loader;

  356.         /** Simple constructor.
  357.          * @param loader loader to monitor
  358.          */
  359.         public MonitoringWrapper(final DataLoader loader) {
  360.             this.loader = loader;
  361.         }

  363.         /** {@inheritDoc} */
  364.         public boolean stillAcceptsData() {
  365.             // delegate to monitored loader
  366.             return loader.stillAcceptsData();
  367.         }

  369.         /** {@inheritDoc} */
  370.         public void loadData(final InputStream input, final String name)
  371.             throws IOException, ParseException, OrekitException {

  373.             // delegate to monitored loader
  374.             loader.loadData(input, name);

  376.             // monitor the fact new data has been loaded
  377.             loaded.add(name);

  379.         }

  381.     }

  383.     /** Holder for the manager singleton.
  384.      * <p>
  385.      * We use the Initialization on demand holder idiom to store
  386.      * the singletons, as it is both thread-safe, efficient (no
  387.      * synchronization) and works with all versions of java.
  388.      * </p>
  389.      */
  390.     private static class LazyHolder {

  392.         /** Unique instance. */
  393.         private static final DataProvidersManager INSTANCE = new DataProvidersManager();

  395.         /** Private constructor.
  396.          * <p>This class is a utility class, it should neither have a public
  397.          * nor a default constructor. This private constructor prevents
  398.          * the compiler from generating one automatically.</p>
  399.          */
  400.         private LazyHolder() {
  401.         }

  403.     }

  405. }
Created with JaCoCo 0.6.3.201306030806