/*
    *  jDTAUS Banking RI CurrencyDirectory
    *  Copyright (C) 2005 Christian Schulte
    *  <cs@schulte.it>
    *
    *  This library is free software; you can redistribute it and/or
    *  modify it under the terms of the GNU Lesser General Public
    *  License as published by the Free Software Foundation; either
    *  version 2.1 of the License, or any later version.
   *
   *  This library is distributed in the hope that it will be useful,
   *  but WITHOUT ANY WARRANTY; without even the implied warranty of
   *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   *  Lesser General Public License for more details.
   *
   *  You should have received a copy of the GNU Lesser General Public
   *  License along with this library; if not, write to the Free Software
   *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
   *
   */
  package org.jdtaus.banking.ri.currencydir;
  
  import java.io.File;
  import java.io.IOException;
  import java.io.InputStream;
  import java.net.URI;
  import java.net.URISyntaxException;
  import java.net.URL;
  import java.text.DateFormat;
  import java.text.ParseException;
  import java.text.SimpleDateFormat;
  import java.util.ArrayList;
  import java.util.Arrays;
  import java.util.Calendar;
  import java.util.Collection;
  import java.util.Currency;
  import java.util.Date;
  import java.util.HashMap;
  import java.util.HashSet;
  import java.util.Iterator;
  import java.util.LinkedList;
  import java.util.Locale;
  import java.util.Map;
  import javax.xml.parsers.DocumentBuilder;
  import javax.xml.parsers.DocumentBuilderFactory;
  import javax.xml.parsers.ParserConfigurationException;
  import org.jdtaus.banking.messages.ReadsCurrenciesMessage;
  import org.jdtaus.banking.messages.SearchesCurrenciesMessage;
  import org.jdtaus.banking.spi.CurrencyMapper;
  import org.jdtaus.banking.spi.UnsupportedCurrencyException;
  import org.jdtaus.core.container.ContainerFactory;
  import org.jdtaus.core.container.PropertyException;
  import org.jdtaus.core.logging.spi.Logger;
  import org.jdtaus.core.monitor.spi.Task;
  import org.jdtaus.core.monitor.spi.TaskMonitor;
  import org.jdtaus.core.sax.util.EntityResolverChain;
  import org.w3c.dom.Document;
  import org.w3c.dom.Element;
  import org.w3c.dom.NodeList;
  import org.xml.sax.ErrorHandler;
  import org.xml.sax.SAXException;
  import org.xml.sax.SAXParseException;
  
  /**
   * Currency directory implementation backed by XML resources.
   * <p>This implementation uses XML resources provided by any available {@link JaxpCurrenciesProvider} implementation.
   * Resources with a {@code file} URI scheme are monitored for changes by querying the last modification time. Monitoring
   * is controlled by property {@code reloadIntervalMillis}.</p>
   *
   * @author <a href="mailto:cs@schulte.it">Christian Schulte</a>
   * @version $JDTAUS: JaxpCurrencyDirectory.java 8865 2014-01-10 17:13:42Z schulte $
   */
  public class JaxpCurrencyDirectory implements CurrencyMapper
  {
  
      /** JAXP configuration key to the Schema implementation attribute. */
      private static final String SCHEMA_LANGUAGE_KEY = "http://java.sun.com/xml/jaxp/properties/schemaLanguage";
  
      /** JAXP Schema implementation to use. */
      private static final String SCHEMA_LANGUAGE = "http://www.w3.org/2001/XMLSchema";
  
      /** jDTAUS {@code currencies} namespace URI. */
      private static final String CURRENCIES_NS = "http://jdtaus.org/banking/xml/currencies";
  
      /** jDTAUS {@code banking} namespace URI. */
      private static final String BANKING_NS = "http://jdtaus.org/banking/model";
  
      /** {@code http://www.w3.org/2001/XMLSchema-instance} namespace URI. */
      private static final String XSI_NS = "http://www.w3.org/2001/XMLSchema-instance";
  
      /** Version supported by this implementation. */
      private static final String[] SUPPORTED_VERSIONS =
      {
          "1.0"
      };
  
      /** Flag indicating that initialization has been performed. */
      private boolean initialized;
  
     /** Maps ISO codes to currency instances. */
     private final Map isoMap = new HashMap();
 
     /** Maps DTAUS codes to currency instances. */
     private final Map dtausMap = new HashMap();
 
     /** Maps {@code File} instances to theire last modification timestamp. */
     private final Map monitorMap = new HashMap();
 
     /** Holds the timestamp resources got checked for modifications. */
     private long lastCheck = System.currentTimeMillis();
 
     /** Number of milliseconds to pass before resources are checked for modifications. */
     private Long reloadIntervalMillis;
 
     /** Number of currencies for which progress monitoring gets enabled. */
     private Long monitoringThreshold;
 
     /**
      * Creates a new {@code JaxpCurrencyDirectory} instance taking the number of milliseconds to pass before resources
      * are checked for modifications and the number of currencies for which progress monitoring gets enabled.
      *
      * @param reloadIntervalMillis Number of milliseconds to pass before resources are checked for modifications.
      * @param monitoringThreshold Number of currencies for which progress monitoring gets enabled.
      */
     public JaxpCurrencyDirectory( final long reloadIntervalMillis, final long monitoringThreshold )
     {
         this();
         if ( reloadIntervalMillis > 0 )
         {
             this.reloadIntervalMillis = new Long( reloadIntervalMillis );
         }
         if ( monitoringThreshold > 0 )
         {
             this.monitoringThreshold = new Long( monitoringThreshold );
         }
     }
 
     /**
      * Gets the number of milliseconds to pass before resources are checked for modifications.
      *
      * @return The number of milliseconds to pass before resources are checked for modifications.
      */
     public long getReloadIntervalMillis()
     {
         if ( this.reloadIntervalMillis == null )
         {
             this.reloadIntervalMillis = this.getDefaultReloadIntervalMillis();
         }
 
         return this.reloadIntervalMillis.longValue();
     }
 
     /**
      * Gets the number of currencies for which progress monitoring gets enabled.
      *
      * @return The number of currencies for which progress monitoring gets enabled.
      */
     public long getMonitoringThreshold()
     {
         if ( this.monitoringThreshold == null )
         {
             this.monitoringThreshold = this.getDefaultMonitoringThreshold();
         }
 
         return this.monitoringThreshold.longValue();
     }
 
     public Currency[] getDtausCurrencies( final Date date )
     {
         if ( date == null )
         {
             throw new NullPointerException( "date" );
         }
 
         this.assertValidProperties();
         this.assertInitialized();
 
         final Collection col = new LinkedList();
 
         if ( !this.isoMap.isEmpty() )
         {
             final Task task = new Task();
             task.setCancelable( true );
             task.setDescription( new SearchesCurrenciesMessage() );
             task.setIndeterminate( false );
             task.setMaximum( this.isoMap.size() );
             task.setMinimum( 0 );
 
             int progress = 0;
             task.setProgress( progress );
 
             try
             {
                 if ( task.getMaximum() > this.getMonitoringThreshold() )
                 {
                     this.getTaskMonitor().monitor( task );
                 }
 
                 for ( final Iterator it = this.isoMap.keySet().iterator(); it.hasNext() && !task.isCancelled(); )
                 {
                     task.setProgress( progress++ );
                     final String isoCode = (String) it.next();
                     final JaxpCurrency currency = (JaxpCurrency) this.isoMap.get( isoCode );
 
                     if ( currency.isValidAt( date ) )
                     {
                         col.add( Currency.getInstance( isoCode ) );
                     }
                 }
 
                 if ( task.isCancelled() )
                 {
                     col.clear();
                 }
             }
             finally
             {
                 if ( task.getMaximum() > this.getMonitoringThreshold() )
                 {
                     this.getTaskMonitor().finish( task );
                 }
             }
         }
 
         return (Currency[]) col.toArray( new Currency[ col.size() ] );
     }
 
     public Currency getDtausCurrency( final char code, final Date date )
     {
         if ( date == null )
         {
             throw new NullPointerException( "date" );
         }
 
         this.assertValidProperties();
         this.assertInitialized();
 
         final JaxpCurrency currency = (JaxpCurrency) this.dtausMap.get( new Character( code ) );
         Currency ret = null;
 
         if ( currency != null && currency.isValidAt( date ) )
         {
             ret = Currency.getInstance( currency.getIsoCode() );
         }
 
         return ret;
     }
 
     public char getDtausCode( final Currency currency, final Date date )
     {
         if ( currency == null )
         {
             throw new NullPointerException( "currency" );
         }
         if ( date == null )
         {
             throw new NullPointerException( "date" );
         }
 
         this.assertValidProperties();
         this.assertInitialized();
 
         final JaxpCurrency xml = (JaxpCurrency) this.isoMap.get( currency.getCurrencyCode() );
 
         if ( xml != null && xml.getDtausCode() != null && xml.isValidAt( date ) )
         {
             return xml.getDtausCode().charValue();
         }
 
         throw new UnsupportedCurrencyException( currency.getCurrencyCode(), date );
     }
 
     /**
      * Initializes the instance to hold the parsed XML currency instances.
      *
      * @see #assertValidProperties()
      * @see #parseResources()
      * @see #transformDocument(Document)
      */
     private synchronized void assertInitialized()
     {
         try
         {
             if ( System.currentTimeMillis() - this.lastCheck > this.getReloadIntervalMillis()
                  && !this.monitorMap.isEmpty() )
             {
                 this.lastCheck = System.currentTimeMillis();
                 for ( final Iterator it = this.monitorMap.entrySet().iterator(); it.hasNext(); )
                 {
                     final Map.Entry entry = (Map.Entry) it.next();
                     final File file = (File) entry.getKey();
                     final Long lastModified = (Long) entry.getValue();
                     assert lastModified != null : "Expected modification time.";
 
                     if ( file.lastModified() != lastModified.longValue() )
                     {
                         this.getLogger().info( this.getChangeInfoMessage( this.getLocale(), file.getAbsolutePath() ) );
                         this.initialized = false;
                         break;
                     }
                 }
             }
 
             if ( !this.initialized )
             {
                 this.monitorMap.clear();
                 this.isoMap.clear();
                 this.dtausMap.clear();
 
                 final Document[] docs = this.parseResources();
                 final Collection col = new LinkedList();
 
                 for ( int i = docs.length - 1; i >= 0; i-- )
                 {
                     col.addAll( Arrays.asList( this.transformDocument( docs[i] ) ) );
                 }
 
                 for ( final Iterator it = col.iterator(); it.hasNext(); )
                 {
                     final JaxpCurrency currency = (JaxpCurrency) it.next();
                     if ( this.isoMap.put( currency.getIsoCode(), currency ) != null
                          || ( currency.getDtausCode() != null
                               && this.dtausMap.put( currency.getDtausCode(), currency ) != null ) )
                     {
                         throw new IllegalStateException( this.getDuplicateCurrencyMessage(
                             this.getLocale(), currency.getIsoCode(),
                             Currency.getInstance( currency.getIsoCode() ).getSymbol( this.getLocale() ) ) );
 
                     }
                 }
 
                 this.getLogger().info( this.getCurrencyInfoMessage(
                     this.getLocale(), new Integer( this.isoMap.size() ), new Integer( docs.length ) ) );
 
                 this.initialized = true;
             }
         }
         catch ( final IOException e )
         {
             this.initialized = false;
             throw new RuntimeException( e );
         }
         catch ( final SAXException e )
         {
             this.initialized = false;
             throw new RuntimeException( e );
         }
         catch ( final ParserConfigurationException e )
         {
             this.initialized = false;
             throw new RuntimeException( e );
         }
         catch ( final ParseException e )
         {
             this.initialized = false;
             throw new RuntimeException( e );
         }
     }
 
     /**
      * Checks configured properties.
      *
      * @throws PropertyException if properties hold invalid values.
      */
     private void assertValidProperties()
     {
         if ( this.getReloadIntervalMillis() < 0L )
         {
             throw new PropertyException( "reloadIntervalMillis", Long.toString( this.getReloadIntervalMillis() ) );
         }
         if ( this.getMonitoringThreshold() < 0L )
         {
             throw new PropertyException( "monitoringThreshold", Long.toString( this.getMonitoringThreshold() ) );
         }
     }
 
     /**
      * Gets XML resources provided by any available {@code CurrenciesProvider} implementation.
      *
      * @return XML resources provided by any available {@code CurrenciesProvider} implementation.
      *
      * @throws IOException if retrieving resources fails.
      *
      * @see JaxpCurrenciesProvider
      */
     private URL[] getResources() throws IOException
     {
         final Collection resources = new HashSet();
         final JaxpCurrenciesProvider[] provider = this.getCurrenciesProvider();
 
         for ( int i = provider.length - 1; i >= 0; i-- )
         {
             resources.addAll( Arrays.asList( provider[i].getResources() ) );
         }
 
         return (URL[]) resources.toArray( new URL[ resources.size() ] );
     }
 
     /**
      * Adds a resource to the list of resources to monitor for changes.
      *
      * @param url The URL of the resource to monitor for changes.
      *
      * @throws NullPointerException if {@code url} is {@code null}.
      */
     private void monitorResource( final URL url )
     {
         if ( url == null )
         {
             throw new NullPointerException( "url" );
         }
 
         try
         {
             final File file = new File( new URI( url.toString() ) );
             this.monitorMap.put( file, new Long( file.lastModified() ) );
             this.getLogger().info( this.getMonitoringInfoMessage( this.getLocale(), file.getAbsolutePath() ) );
         }
         catch ( final IllegalArgumentException e )
         {
             this.getLogger().info( this.getNotMonitoringWarningMessage(
                 this.getLocale(), url.toExternalForm(), e.getMessage() ) );
 
         }
         catch ( final URISyntaxException e )
         {
             this.getLogger().info( this.getNotMonitoringWarningMessage(
                 this.getLocale(), url.toExternalForm(), e.getMessage() ) );
 
         }
     }
 
     /**
      * Parses all XML resources.
      *
      * @return The parsed documents.
      *
      * @see #getResources()
      * @see #getDocumentBuilder()
      *
      * @throws IOException if retrieving resources fails.
      * @throws ParserConfigurationException if configuring the XML parser fails.
      * @throws SAXException if parsing fails.
      */
     private Document[] parseResources() throws IOException, ParserConfigurationException, SAXException
     {
         InputStream stream = null;
 
         final URL[] resources = this.getResources();
         final Document[] ret = new Document[ resources.length ];
 
         if ( resources.length > 0 )
         {
             final DocumentBuilder validatingParser = this.getDocumentBuilder();
             final DocumentBuilderFactory namespaceAwareFactory = DocumentBuilderFactory.newInstance();
             namespaceAwareFactory.setNamespaceAware( true );
             final DocumentBuilder nonValidatingParser = namespaceAwareFactory.newDocumentBuilder();
 
             final Task task = new Task();
             task.setCancelable( false );
             task.setDescription( new ReadsCurrenciesMessage() );
             task.setIndeterminate( false );
             task.setMaximum( resources.length - 1 );
             task.setMinimum( 0 );
             task.setProgress( 0 );
 
             try
             {
                 this.getTaskMonitor().monitor( task );
 
                 for ( int i = resources.length - 1; i >= 0; i-- )
                 {
                     task.setProgress( task.getMaximum() - i );
 
                     final URL resource = resources[i];
                     final ErrorHandler errorHandler = new ErrorHandler()
                     {
 
                         public void warning( final SAXParseException e ) throws SAXException
                         {
                             getLogger().warn( getParseExceptionMessage(
                                 getLocale(), resource.toExternalForm(),
                                 e.getMessage(), new Integer( e.getLineNumber() ),
                                 new Integer( e.getColumnNumber() ) ) );
 
                         }
 
                         public void error( final SAXParseException e ) throws SAXException
                         {
                             throw new SAXException( getParseExceptionMessage(
                                 getLocale(), resource.toExternalForm(),
                                 e.getMessage(), new Integer( e.getLineNumber() ),
                                 new Integer( e.getColumnNumber() ) ), e );
 
                         }
 
                         public void fatalError( final SAXParseException e ) throws SAXException
                         {
                             throw new SAXException( getParseExceptionMessage(
                                 getLocale(), resource.toExternalForm(),
                                 e.getMessage(), new Integer( e.getLineNumber() ),
                                 new Integer( e.getColumnNumber() ) ), e );
 
                         }
 
                     };
 
                     nonValidatingParser.setErrorHandler( errorHandler );
                     validatingParser.setErrorHandler( errorHandler );
 
                     try
                     {
                         this.monitorResource( resources[i] );
                         stream = resources[i].openStream();
                         ret[i] = nonValidatingParser.parse( stream );
 
                         if ( ret[i].getDocumentElement().hasAttributeNS( XSI_NS, "schemaLocation" ) )
                         {
                             stream.close();
                             stream = resources[i].openStream();
                             ret[i] = validatingParser.parse( stream );
                         }
                         else if ( this.getLogger().isInfoEnabled() )
                         {
                             this.getLogger().info( this.getNoSchemaLocationMessage(
                                 this.getLocale(), resources[i].toExternalForm() ) );
 
                         }
                     }
                     finally
                     {
                         if ( stream != null )
                         {
                             stream.close();
                             stream = null;
                         }
                     }
                 }
             }
             finally
             {
                 this.getTaskMonitor().finish( task );
             }
         }
         else
         {
             this.getLogger().warn( this.getNoCurrenciesFoundMessage( this.getLocale() ) );
         }
 
         return ret;
     }
 
     /**
      * Transforms a XML document to the currency instances it contains.
      *
      * @param doc The document to transform.
      *
      * @return An array of the currency instances from the given document.
      *
      * @throws ParseException if parsing values fails.
      */
     private JaxpCurrency[] transformDocument( final Document doc ) throws ParseException
     {
         final Calendar cal = Calendar.getInstance();
         final DateFormat dateFormat = new SimpleDateFormat( "yyyy-MM-dd" );
         final Collection col = new ArrayList( 500 );
 
         String modelVersion = null;
         final String namespace = doc.getDocumentElement().getNamespaceURI();
 
         if ( namespace == null )
         {
             throw new RuntimeException( this.getUnsupportedNamespaceMessage( this.getLocale(), null ) );
         }
         else if ( CURRENCIES_NS.equals( namespace ) )
         {
             modelVersion = doc.getDocumentElement().getAttributeNS( namespace, "version" );
         }
         else if ( BANKING_NS.equals( namespace ) )
         {
             modelVersion = doc.getDocumentElement().getAttributeNS( namespace, "modelVersion" );
         }
         else
         {
             throw new RuntimeException( this.getUnsupportedNamespaceMessage( this.getLocale(), namespace ) );
         }
 
         boolean supportedModelVersion = false;
         for ( int i = SUPPORTED_VERSIONS.length - 1; i >= 0; i-- )
         {
             if ( SUPPORTED_VERSIONS[i].equals( modelVersion ) )
             {
                 supportedModelVersion = true;
                 break;
             }
         }
 
         if ( !supportedModelVersion )
         {
             throw new RuntimeException( this.getUnsupportedModelVersionMessage( this.getLocale(), modelVersion ) );
         }
 
         final NodeList l = doc.getDocumentElement().getElementsByTagNameNS( namespace, "currency" );
 
         for ( int i = l.getLength() - 1; i >= 0; i-- )
         {
             final Element e = (Element) l.item( i );
 
             if ( e.getParentNode().equals( doc.getDocumentElement() ) )
             {
                 final JaxpCurrency cur = new JaxpCurrency();
                 cur.setIsoCode( e.getAttributeNS( namespace, "isoCode" ) );
 
                 if ( e.hasAttributeNS( namespace, "dtausCode" ) )
                 {
                     cur.setDtausCode( new Character( e.getAttributeNS( namespace, "dtausCode" ).charAt( 0 ) ) );
                 }
 
                 cal.setTime( dateFormat.parse( e.getAttributeNS( namespace, "startDate" ) ) );
                 cal.set( Calendar.HOUR_OF_DAY, 0 );
                 cal.set( Calendar.MINUTE, 0 );
                 cal.set( Calendar.SECOND, 0 );
                 cal.set( Calendar.MILLISECOND, 0 );
                 cur.setStartDate( cal.getTime() );
 
                 if ( e.hasAttributeNS( namespace, "endDate" ) )
                 {
                     cal.setTime( dateFormat.parse( e.getAttributeNS( namespace, "endDate" ) ) );
                     cal.set( Calendar.HOUR_OF_DAY, 23 );
                     cal.set( Calendar.MINUTE, 59 );
                     cal.set( Calendar.SECOND, 59 );
                     cal.set( Calendar.MILLISECOND, 999 );
                     cur.setEndDate( cal.getTime() );
                 }
 
                 col.add( cur );
             }
         }
 
         return (JaxpCurrency[]) col.toArray( new JaxpCurrency[ col.size() ] );
     }
 
     /**
      * Creates a new {@code DocumentBuilder} to use for parsing the XML resources.
      * <p>This method tries to set the following JAXP property on the system's default XML parser:
      * <ul>
      * <li>{@code http://java.sun.com/xml/jaxp/properties/schemaLanguage} set to
      * {@code http://www.w3.org/2001/XMLSchema}</li>
      * </ul> When setting this property fails, a non-validating
      * {@code DocumentBuilder} is returned and a warning message is logged.</p>
      *
      * @return A new {@code DocumentBuilder} to be used for parsing resources.
      *
      * @throws ParserConfigurationException if configuring the XML parser fails.
      */
     private DocumentBuilder getDocumentBuilder() throws ParserConfigurationException
     {
         final DocumentBuilder xmlBuilder;
         final DocumentBuilderFactory xmlFactory = DocumentBuilderFactory.newInstance();
         xmlFactory.setNamespaceAware( true );
 
         try
         {
             xmlFactory.setValidating( true );
             xmlFactory.setAttribute( SCHEMA_LANGUAGE_KEY, SCHEMA_LANGUAGE );
         }
         catch ( final IllegalArgumentException e )
         {
             this.getLogger().info( this.getNoJAXPValidationWarningMessage( this.getLocale(), e.getMessage() ) );
             xmlFactory.setValidating( false );
         }
 
         xmlBuilder = xmlFactory.newDocumentBuilder();
         xmlBuilder.setEntityResolver( new EntityResolverChain() );
         return xmlBuilder;
     }
 
     //--Constructors------------------------------------------------------------
 
 // <editor-fold defaultstate="collapsed" desc=" Generated Code ">//GEN-BEGIN:jdtausConstructors
     // This section is managed by jdtaus-container-mojo.
 
     /** Standard implementation constructor <code>org.jdtaus.banking.ri.currencydir.JaxpCurrencyDirectory</code>. */
     public JaxpCurrencyDirectory()
     {
         super();
     }
 
 // </editor-fold>//GEN-END:jdtausConstructors
 
     //------------------------------------------------------------Constructors--
     //--Dependencies------------------------------------------------------------
 
 // <editor-fold defaultstate="collapsed" desc=" Generated Code ">//GEN-BEGIN:jdtausDependencies
     // This section is managed by jdtaus-container-mojo.
 
     /**
      * Gets the configured <code>Logger</code> implementation.
      *
      * @return The configured <code>Logger</code> implementation.
      */
     private Logger getLogger()
     {
         return (Logger) ContainerFactory.getContainer().
             getDependency( this, "Logger" );
 
     }
 
     /**
      * Gets the configured <code>CurrenciesProvider</code> implementation.
      *
      * @return The configured <code>CurrenciesProvider</code> implementation.
      */
     private JaxpCurrenciesProvider[] getCurrenciesProvider()
     {
         return (JaxpCurrenciesProvider[]) ContainerFactory.getContainer().
             getDependency( this, "CurrenciesProvider" );
 
     }
 
     /**
      * Gets the configured <code>TaskMonitor</code> implementation.
      *
      * @return The configured <code>TaskMonitor</code> implementation.
      */
     private TaskMonitor getTaskMonitor()
     {
         return (TaskMonitor) ContainerFactory.getContainer().
             getDependency( this, "TaskMonitor" );
 
     }
 
     /**
      * Gets the configured <code>Locale</code> implementation.
      *
      * @return The configured <code>Locale</code> implementation.
      */
     private Locale getLocale()
     {
         return (Locale) ContainerFactory.getContainer().
             getDependency( this, "Locale" );
 
     }
 
 // </editor-fold>//GEN-END:jdtausDependencies
 
     //------------------------------------------------------------Dependencies--
     //--Properties--------------------------------------------------------------
 
 // <editor-fold defaultstate="collapsed" desc=" Generated Code ">//GEN-BEGIN:jdtausProperties
     // This section is managed by jdtaus-container-mojo.
 
     /**
      * Gets the value of property <code>defaultReloadIntervalMillis</code>.
      *
      * @return Default number of milliseconds to pass before resources are checked for modifications.
      */
     private java.lang.Long getDefaultReloadIntervalMillis()
     {
         return (java.lang.Long) ContainerFactory.getContainer().
             getProperty( this, "defaultReloadIntervalMillis" );
 
     }
 
     /**
      * Gets the value of property <code>defaultMonitoringThreshold</code>.
      *
      * @return Default number of currencies for which progress monitoring gets enabled.
      */
     private java.lang.Long getDefaultMonitoringThreshold()
     {
         return (java.lang.Long) ContainerFactory.getContainer().
             getProperty( this, "defaultMonitoringThreshold" );
 
     }
 
 // </editor-fold>//GEN-END:jdtausProperties
 
     //--------------------------------------------------------------Properties--
     //--Messages----------------------------------------------------------------
 
 // <editor-fold defaultstate="collapsed" desc=" Generated Code ">//GEN-BEGIN:jdtausMessages
     // This section is managed by jdtaus-container-mojo.
 
     /**
      * Gets the text of message <code>noJAXPValidationWarning</code>.
      * <blockquote><pre>Keine JAXP Validierung verfügbar. {0}</pre></blockquote>
      * <blockquote><pre>No JAXP validation available. {0}</pre></blockquote>
      *
      * @param locale The locale of the message instance to return.
      * @param detailMessage format parameter.
      *
      * @return the text of message <code>noJAXPValidationWarning</code>.
      */
     private String getNoJAXPValidationWarningMessage( final Locale locale,
             final java.lang.String detailMessage )
     {
         return ContainerFactory.getContainer().
             getMessage( this, "noJAXPValidationWarning", locale,
                 new Object[]
                 {
                     detailMessage
                 });
 
     }
 
     /**
      * Gets the text of message <code>notMonitoringWarning</code>.
      * <blockquote><pre>{0} kann bei Änderung nicht automatisch neu geladen werden. {1}</pre></blockquote>
      * <blockquote><pre>{0} cannot be monitored. {1}</pre></blockquote>
      *
      * @param locale The locale of the message instance to return.
      * @param resourceName format parameter.
      * @param detailMessage format parameter.
      *
      * @return the text of message <code>notMonitoringWarning</code>.
      */
     private String getNotMonitoringWarningMessage( final Locale locale,
             final java.lang.String resourceName,
             final java.lang.String detailMessage )
     {
         return ContainerFactory.getContainer().
             getMessage( this, "notMonitoringWarning", locale,
                 new Object[]
                 {
                     resourceName,
                     detailMessage
                 });
 
     }
 
     /**
      * Gets the text of message <code>changeInfo</code>.
      * <blockquote><pre>{0} aktualisiert.</pre></blockquote>
      * <blockquote><pre>{0} changed.</pre></blockquote>
      *
      * @param locale The locale of the message instance to return.
      * @param resourceName format parameter.
      *
      * @return the text of message <code>changeInfo</code>.
      */
     private String getChangeInfoMessage( final Locale locale,
             final java.lang.String resourceName )
     {
         return ContainerFactory.getContainer().
             getMessage( this, "changeInfo", locale,
                 new Object[]
                 {
                     resourceName
                 });
 
     }
 
     /**
      * Gets the text of message <code>monitoringInfo</code>.
      * <blockquote><pre>{0} wird bei Änderung automatisch neu geladen.</pre></blockquote>
      * <blockquote><pre>Monitoring {0} for changes.</pre></blockquote>
      *
      * @param locale The locale of the message instance to return.
      * @param resourceName format parameter.
      *
      * @return the text of message <code>monitoringInfo</code>.
      */
     private String getMonitoringInfoMessage( final Locale locale,
             final java.lang.String resourceName )
     {
         return ContainerFactory.getContainer().
             getMessage( this, "monitoringInfo", locale,
                 new Object[]
                 {
                     resourceName
                 });
 
     }
 
     /**
      * Gets the text of message <code>parseException</code>.
      * <blockquote><pre>Fehler bei der Verarbeitung der Resource "{0}" in Zeile {2}, Spalte {3}. {1}</pre></blockquote>
      * <blockquote><pre>Error parsing resource "{0}" at line {2}, column {3}. {1}</pre></blockquote>
      *
      * @param locale The locale of the message instance to return.
      * @param resourceName format parameter.
      * @param cause format parameter.
      * @param line format parameter.
      * @param column format parameter.
      *
      * @return the text of message <code>parseException</code>.
      */
     private String getParseExceptionMessage( final Locale locale,
             final java.lang.String resourceName,
             final java.lang.String cause,
             final java.lang.Number line,
             final java.lang.Number column )
     {
         return ContainerFactory.getContainer().
             getMessage( this, "parseException", locale,
                 new Object[]
                 {
                     resourceName,
                     cause,
                     line,
                     column
                 });
 
     }
 
     /**
      * Gets the text of message <code>unsupportedNamespace</code>.
      * <blockquote><pre>Ungültiger XML-Namensraum {0}.</pre></blockquote>
      * <blockquote><pre>Unsupported XML namespace {0}.</pre></blockquote>
      *
      * @param locale The locale of the message instance to return.
      * @param namespace format parameter.
      *
      * @return the text of message <code>unsupportedNamespace</code>.
      */
     private String getUnsupportedNamespaceMessage( final Locale locale,
             final java.lang.String namespace )
     {
         return ContainerFactory.getContainer().
             getMessage( this, "unsupportedNamespace", locale,
                 new Object[]
                 {
                     namespace
                 });
 
     }
 
     /**
      * Gets the text of message <code>unsupportedModelVersion</code>.
      * <blockquote><pre>Keine Unterstützung für Modellversion {0}.</pre></blockquote>
      * <blockquote><pre>Unsupported model version {0}.</pre></blockquote>
      *
      * @param locale The locale of the message instance to return.
      * @param modelVersion format parameter.
      *
      * @return the text of message <code>unsupportedModelVersion</code>.
      */
     private String getUnsupportedModelVersionMessage( final Locale locale,
             final java.lang.String modelVersion )
     {
         return ContainerFactory.getContainer().
             getMessage( this, "unsupportedModelVersion", locale,
                 new Object[]
                 {
                     modelVersion
                 });
 
     }
 
     /**
      * Gets the text of message <code>currencyInfo</code>.
      * <blockquote><pre>{1,choice,0#Kein Dokument|1#Ein Dokument|1<{1} Dokumente} gelesen. {0,choice,0#Keine Währung|1#Eine Währung|1<{0} Währungen} verarbeitet.</pre></blockquote>
      * <blockquote><pre>Read {1,choice,0#no document|1#one document|1<{1} documents}. Processed {0,choice,0#no entities|1#one entity|1<{0} entities}.</pre></blockquote>
      *
      * @param locale The locale of the message instance to return.
      * @param entityCount format parameter.
      * @param documentCount format parameter.
      *
      * @return the text of message <code>currencyInfo</code>.
      */
     private String getCurrencyInfoMessage( final Locale locale,
             final java.lang.Number entityCount,
             final java.lang.Number documentCount )
     {
         return ContainerFactory.getContainer().
             getMessage( this, "currencyInfo", locale,
                 new Object[]
                 {
                     entityCount,
                     documentCount
                 });
 
     }
 
     /**
      * Gets the text of message <code>noSchemaLocation</code>.
      * <blockquote><pre>Kein schemaLocation Attribut in Ressource "{0}". Keine Schema-Validierung.</pre></blockquote>
      * <blockquote><pre>No schemaLocation attribute in resource "{0}". Schema validation skipped.</pre></blockquote>
      *
      * @param locale The locale of the message instance to return.
      * @param resource format parameter.
      *
      * @return the text of message <code>noSchemaLocation</code>.
      */
     private String getNoSchemaLocationMessage( final Locale locale,
             final java.lang.String resource )
     {
         return ContainerFactory.getContainer().
             getMessage( this, "noSchemaLocation", locale,
                 new Object[]
                 {
                     resource
                 });
 
     }
 
     /**
      * Gets the text of message <code>duplicateCurrency</code>.
      * <blockquote><pre>Währung {1} ({0}) ist mehrfach vorhanden.</pre></blockquote>
      * <blockquote><pre>Non-unique currency {1} ({0}).</pre></blockquote>
      *
      * @param locale The locale of the message instance to return.
      * @param currencyCode format parameter.
      * @param currencySymbol format parameter.
      *
      * @return the text of message <code>duplicateCurrency</code>.
      */
     private String getDuplicateCurrencyMessage( final Locale locale,
             final java.lang.String currencyCode,
             final java.lang.String currencySymbol )
     {
         return ContainerFactory.getContainer().
             getMessage( this, "duplicateCurrency", locale,
                 new Object[]
                 {
                     currencyCode,
                     currencySymbol
                 });
 
     }
 
     /**
      * Gets the text of message <code>noCurrenciesFound</code>.
      * <blockquote><pre>Keine Währungen gefunden.</pre></blockquote>
      * <blockquote><pre>No currencies found.</pre></blockquote>
      *
      * @param locale The locale of the message instance to return.
      *
      * @return the text of message <code>noCurrenciesFound</code>.
      */
     private String getNoCurrenciesFoundMessage( final Locale locale )
     {
         return ContainerFactory.getContainer().
             getMessage( this, "noCurrenciesFound", locale, null );
 
     }
 
 // </editor-fold>//GEN-END:jdtausMessages
 
     //----------------------------------------------------------------Messages--
 }