/*
    *   Copyright (C) 2005 Christian Schulte <cs@schulte.it>
    *   All rights reserved.
    *
    *   Redistribution and use in source and binary forms, with or without
    *   modification, are permitted provided that the following conditions
    *   are met:
    *
    *     o Redistributions of source code must retain the above copyright
   *       notice, this list of conditions and the following disclaimer.
   *
   *     o Redistributions in binary form must reproduce the above copyright
   *       notice, this list of conditions and the following disclaimer in
   *       the documentation and/or other materials provided with the
   *       distribution.
   *
   *   THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
   *   INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
   *   AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
   *   THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY DIRECT, INDIRECT,
   *   INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
   *   NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
   *   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
   *   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
   *   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
   *   THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
   *
   *   $JOMC: ProjectClassLoader.java 5303 2016-08-30 02:31:20Z schulte $
   *
   */
  package org.jomc.ant;
  
  import java.io.BufferedReader;
  import java.io.BufferedWriter;
  import java.io.Closeable;
  import java.io.File;
  import java.io.FileOutputStream;
  import java.io.IOException;
  import java.io.InputStream;
  import java.io.InputStreamReader;
  import java.io.OutputStream;
  import java.io.OutputStreamWriter;
  import java.net.MalformedURLException;
  import java.net.URI;
  import java.net.URISyntaxException;
  import java.net.URL;
  import java.net.URLClassLoader;
  import java.util.Collections;
  import java.util.Enumeration;
  import java.util.HashSet;
  import java.util.Iterator;
  import java.util.LinkedList;
  import java.util.List;
  import java.util.Set;
  import javax.xml.bind.JAXBElement;
  import javax.xml.bind.JAXBException;
  import org.apache.tools.ant.Project;
  import org.apache.tools.ant.types.Path;
  import org.codehaus.mojo.animal_sniffer.IgnoreJRERequirement;
  import org.jomc.modlet.ModelContext;
  import org.jomc.modlet.ModelContextFactory;
  import org.jomc.modlet.ModelException;
  import org.jomc.modlet.Modlet;
  import org.jomc.modlet.ModletObject;
  import org.jomc.modlet.Modlets;
  import org.jomc.modlet.ObjectFactory;
  import org.jomc.modlet.Schema;
  import org.jomc.modlet.Schemas;
  import org.jomc.modlet.Service;
  import org.jomc.modlet.Services;
  import org.jomc.util.ParseException;
  import org.jomc.util.TokenMgrError;
  import org.jomc.util.VersionParser;
  
  /**
   * Class loader supporting JOMC resources backed by a project.
   *
   * @author <a href="mailto:cs@schulte.it">Christian Schulte</a>
   * @version $JOMC: ProjectClassLoader.java 5303 2016-08-30 02:31:20Z schulte $
   */
  public class ProjectClassLoader extends URLClassLoader
  {
  
      /**
       * Constant to prefix relative resource names with.
       */
      private static final String ABSOLUTE_RESOURCE_NAME_PREFIX =
          "/" + ProjectClassLoader.class.getPackage().getName().replace( '.', '/' ) + "/";
  
      /**
       * Empty URL array.
       */
      private static final URL[] NO_URLS =
      {
      };
  
      /**
       * Set of modlet names to exclude.
       */
     private Set<String> modletExcludes;
 
     /**
      * Excluded modlets.
      */
     private final Modlets excludedModlets = new Modlets();
 
     /**
      * Set of service class names to exclude.
      */
     private Set<String> serviceExcludes;
 
     /**
      * Excluded services.
      */
     private final Services excludedServices = new Services();
 
     /**
      * Set of schema public ids to exclude.
      */
     private Set<String> schemaExcludes;
 
     /**
      * Excluded schemas.
      */
     private final Schemas excludedSchemas = new Schemas();
 
     /**
      * Set of providers to exclude.
      */
     private Set<String> providerExcludes;
 
     /**
      * Set of excluded providers.
      */
     private final Set<String> excludedProviders = Collections.synchronizedSet( new HashSet<String>( 128 ) );
 
     /**
      * The project the class loader is associated with.
      */
     private final Project project;
 
     /**
      * Set of modlet resource locations to filter.
      */
     private Set<String> modletResourceLocations;
 
     /**
      * Set of provider resource locations to filter.
      */
     private Set<String> providerResourceLocations;
 
     /**
      * Set of temporary resources.
      */
     private final Set<File> temporaryResources = Collections.synchronizedSet( new HashSet<File>( 128 ) );
 
     /**
      * Creates a new {@code ProjectClassLoader} instance taking a project and a class path.
      *
      * @param project The project to which this class loader is to belong.
      * @param classpath The class path to use for loading.
      *
      * @throws MalformedURLException if {@code classpath} contains unsupported elements.
      * @throws IOException if reading configuration resources fails.
      */
     public ProjectClassLoader( final Project project, final Path classpath ) throws MalformedURLException, IOException
     {
         super( NO_URLS, ProjectClassLoader.class.getClassLoader() );
 
         for ( final String name : classpath.list() )
         {
             final File resolved = project.resolveFile( name );
             this.addURL( resolved.toURI().toURL() );
         }
 
         this.project = project;
     }
 
     /**
      * Gets the project of the instance.
      *
      * @return The project of the instance.
      */
     public final Project getProject()
     {
         return this.project;
     }
 
     /**
      * Finds a resource with a given name.
      *
      * @param name The name of the resource to search.
      *
      * @return An {@code URL} object for reading the resource or {@code null}, if no resource matching {@code name} is
      * found.
      */
     @Override
     public URL findResource( final String name ) //JDK: As of JDK 23 throws IOException
     {
         try
         {
             URL resource = super.findResource( name );
 
             if ( resource != null )
             {
                 if ( this.getProviderResourceLocations().contains( name ) )
                 {
                     resource = this.filterProviders( resource );
                 }
                 else if ( this.getModletResourceLocations().contains( name ) )
                 {
                     resource = this.filterModlets( resource );
                 }
             }
 
             return resource;
         }
         catch ( final IOException e )
         {
             this.getProject().log( Messages.getMessage( e ), Project.MSG_ERR );
             return null;
         }
         catch ( final JAXBException e )
         {
             String message = Messages.getMessage( e );
             if ( message == null && e.getLinkedException() != null )
             {
                 message = Messages.getMessage( e.getLinkedException() );
             }
 
             this.getProject().log( message, Project.MSG_ERR );
             return null;
         }
         catch ( final ModelException e )
         {
             this.getProject().log( Messages.getMessage( e ), Project.MSG_ERR );
             return null;
         }
     }
 
     /**
      * Finds all resources matching a given name.
      *
      * @param name The name of the resources to search.
      *
      * @return An enumeration of {@code URL} objects of resources matching name.
      *
      * @throws IOException if getting resources fails.
      */
     @Override
     public Enumeration<URL> findResources( final String name ) throws IOException
     {
         try
         {
             Enumeration<URL> resources = super.findResources( name );
 
             if ( this.getProviderResourceLocations().contains( name )
                      || this.getModletResourceLocations().contains( name ) )
             {
                 final List<URI> filtered = new LinkedList<URI>();
 
                 while ( resources.hasMoreElements() )
                 {
                     final URL resource = resources.nextElement();
 
                     if ( this.getProviderResourceLocations().contains( name ) )
                     {
                         filtered.add( this.filterProviders( resource ).toURI() );
                     }
                     else if ( this.getModletResourceLocations().contains( name ) )
                     {
                         filtered.add( this.filterModlets( resource ).toURI() );
                     }
                 }
 
                 final Iterator<URI> it = filtered.iterator();
 
                 resources = new Enumeration<URL>()
                 {
 
                     public boolean hasMoreElements()
                     {
                         return it.hasNext();
                     }
 
                     public URL nextElement()
                     {
                         try
                         {
                             return it.next().toURL();
                         }
                         catch ( final MalformedURLException e )
                         {
                             throw new AssertionError( e );
                         }
                     }
 
                 };
             }
 
             return resources;
         }
         catch ( final URISyntaxException e )
         {
             // JDK: As of JDK 6, new IOException( message, e );
             throw (IOException) new IOException( Messages.getMessage( e ) ).initCause( e );
         }
         catch ( final JAXBException e )
         {
             String message = Messages.getMessage( e );
             if ( message == null && e.getLinkedException() != null )
             {
                 message = Messages.getMessage( e.getLinkedException() );
             }
 
             // JDK: As of JDK 6, new IOException( message, e );
             throw (IOException) new IOException( message ).initCause( e );
         }
         catch ( final ModelException e )
         {
             // JDK: As of JDK 6, new IOException( message, e );
             throw (IOException) new IOException( Messages.getMessage( e ) ).initCause( e );
         }
     }
 
     /**
      * Gets a set of modlet resource locations to filter.
      * <p>
      * This accessor method returns a reference to the live set, not a snapshot. Therefore any modification you make
      * to the returned set will be present inside the object. This is why there is no {@code set} method for the
      * modlet resource locations property.
      * </p>
      *
      * @return A set of modlet resource locations to filter.
      */
     public final Set<String> getModletResourceLocations()
     {
         if ( this.modletResourceLocations == null )
         {
             this.modletResourceLocations = new HashSet<String>( 128 );
         }
 
         return this.modletResourceLocations;
     }
 
     /**
      * Gets a set of provider resource locations to filter.
      * <p>
      * This accessor method returns a reference to the live set, not a snapshot. Therefore any modification you make
      * to the returned set will be present inside the object. This is why there is no {@code set} method for the
      * provider resource locations property.
      * </p>
      *
      * @return A set of provider resource locations to filter.
      */
     public final Set<String> getProviderResourceLocations()
     {
         if ( this.providerResourceLocations == null )
         {
             this.providerResourceLocations = new HashSet<String>( 128 );
         }
 
         return this.providerResourceLocations;
     }
 
     /**
      * Gets a set of modlet names to exclude.
      * <p>
      * This accessor method returns a reference to the live set, not a snapshot. Therefore any modification you make
      * to the returned set will be present inside the object. This is why there is no {@code set} method for the
      * modlet excludes property.
      * </p>
      *
      * @return A set of modlet names to exclude.
      */
     public final Set<String> getModletExcludes()
     {
         if ( this.modletExcludes == null )
         {
             this.modletExcludes = new HashSet<String>( 128 );
         }
 
         return this.modletExcludes;
     }
 
     /**
      * Gets a set of modlet names excluded by default.
      *
      * @return An unmodifiable set of modlet names excluded by default.
      *
      * @throws IOException if reading configuration resources fails.
      */
     public static Set<String> getDefaultModletExcludes() throws IOException
     {
         return readDefaultExcludes( ABSOLUTE_RESOURCE_NAME_PREFIX + "DefaultModletExcludes" );
     }
 
     /**
      * Gets a set of modlets excluded during resource loading.
      * <p>
      * This accessor method returns a reference to the live set, not a snapshot. Therefore any modification you make
      * to the returned set will be present inside the object. This is why there is no {@code set} method for the
      * excluded modlets property.
      * </p>
      *
      * @return A set of modlets excluded during resource loading.
      */
     public final Modlets getExcludedModlets()
     {
         return this.excludedModlets;
     }
 
     /**
      * Gets a set of provider names to exclude.
      * <p>
      * This accessor method returns a reference to the live set, not a snapshot. Therefore any modification you make
      * to the returned set will be present inside the object. This is why there is no {@code set} method for the
      * provider excludes property.
      * </p>
      *
      * @return A set of providers to exclude.
      */
     public final Set<String> getProviderExcludes()
     {
         if ( this.providerExcludes == null )
         {
             this.providerExcludes = new HashSet<String>( 128 );
         }
 
         return this.providerExcludes;
     }
 
     /**
      * Gets a set of provider names excluded by default.
      *
      * @return An unmodifiable set of provider names excluded by default.
      *
      * @throws IOException if reading configuration resources fails.
      */
     public static Set<String> getDefaultProviderExcludes() throws IOException
     {
         return readDefaultExcludes( ABSOLUTE_RESOURCE_NAME_PREFIX + "DefaultProviderExcludes" );
     }
 
     /**
      * Gets a set of providers excluded during resource loading.
      * <p>
      * This accessor method returns a reference to the live set, not a snapshot. Therefore any modification you make
      * to the returned set will be present inside the object. This is why there is no {@code set} method for the
      * excluded providers property.
      * </p>
      *
      * @return A set of providers excluded during resource loading.
      */
     public final Set<String> getExcludedProviders()
     {
         return this.excludedProviders;
     }
 
     /**
      * Gets a set of service class names to exclude.
      * <p>
      * This accessor method returns a reference to the live set, not a snapshot. Therefore any modification you make
      * to the returned set will be present inside the object. This is why there is no {@code set} method for the
      * service excludes property.
      * </p>
      *
      * @return A set of service class names to exclude.
      */
     public final Set<String> getServiceExcludes()
     {
         if ( this.serviceExcludes == null )
         {
             this.serviceExcludes = new HashSet<String>( 128 );
         }
 
         return this.serviceExcludes;
     }
 
     /**
      * Gets a set of service class names excluded by default.
      *
      * @return An unmodifiable set of service class names excluded by default.
      *
      * @throws IOException if reading configuration resources fails.
      */
     public static Set<String> getDefaultServiceExcludes() throws IOException
     {
         return readDefaultExcludes( ABSOLUTE_RESOURCE_NAME_PREFIX + "DefaultServiceExcludes" );
     }
 
     /**
      * Gets a set of services excluded during resource loading.
      * <p>
      * This accessor method returns a reference to the live set, not a snapshot. Therefore any modification you make
      * to the returned set will be present inside the object. This is why there is no {@code set} method for the
      * excluded services property.
      * </p>
      *
      * @return Services excluded during resource loading.
      */
     public final Services getExcludedServices()
     {
         return this.excludedServices;
     }
 
     /**
      * Gets a set of schema public identifiers to exclude.
      * <p>
      * This accessor method returns a reference to the live set, not a snapshot. Therefore any modification you make
      * to the returned set will be present inside the object. This is why there is no {@code set} method for the
      * schema excludes property.
      * </p>
      *
      * @return A set of schema public identifiers to exclude.
      */
     public final Set<String> getSchemaExcludes()
     {
         if ( this.schemaExcludes == null )
         {
             this.schemaExcludes = new HashSet<String>( 128 );
         }
 
         return this.schemaExcludes;
     }
 
     /**
      * Gets a set of schema public identifiers excluded by default.
      *
      * @return An unmodifiable set of schema public identifiers excluded by default.
      *
      * @throws IOException if reading configuration resources fails.
      */
     public static Set<String> getDefaultSchemaExcludes() throws IOException
     {
         return readDefaultExcludes( ABSOLUTE_RESOURCE_NAME_PREFIX + "DefaultSchemaExcludes" );
     }
 
     /**
      * Gets a set of schemas excluded during resource loading.
      * <p>
      * This accessor method returns a reference to the live set, not a snapshot. Therefore any modification you make
      * to the returned set will be present inside the object. This is why there is no {@code set} method for the
      * excluded schemas property.
      * </p>
      *
      * @return Schemas excluded during resource loading.
      */
     public final Schemas getExcludedSchemas()
     {
         return this.excludedSchemas;
     }
 
     /**
      * Closes the class loader.
      *
      * @throws IOException if closing the class loader fails.
      */
     @Override
     @IgnoreJRERequirement
     public void close() throws IOException
     {
         for ( final Iterator<File> it = this.temporaryResources.iterator(); it.hasNext(); )
         {
             final File temporaryResource = it.next();
 
             if ( temporaryResource.exists() && temporaryResource.delete() )
             {
                 it.remove();
             }
         }
 
         if ( Closeable.class.isAssignableFrom( ProjectClassLoader.class ) )
         {
             super.close();
         }
     }
 
     /**
      * Removes temporary resources.
      *
      * @throws Throwable if finalization fails.
      */
     @Override
     protected void finalize() throws Throwable
     {
         for ( final Iterator<File> it = this.temporaryResources.iterator(); it.hasNext(); )
         {
             final File temporaryResource = it.next();
 
             if ( temporaryResource.exists() && !temporaryResource.delete() )
             {
                 temporaryResource.deleteOnExit();
             }
 
             it.remove();
         }
 
         super.finalize();
     }
 
     private URL filterProviders( final URL resource ) throws IOException
     {
         InputStream in = null;
         BufferedReader reader = null;
         OutputStream out = null;
         BufferedWriter writer = null;
         URL filteredResource = resource;
         final List<String> filteredLines = new LinkedList<String>();
 
         try
         {
             boolean filtered = false;
             in = resource.openStream();
             reader = new BufferedReader( new InputStreamReader( in, "UTF-8" ) );
 
             for ( String line = reader.readLine(); line != null; line = reader.readLine() )
             {
                 String normalized = line.trim();
 
                 if ( !this.getProviderExcludes().contains( normalized ) )
                 {
                     filteredLines.add( normalized );
                 }
                 else
                 {
                     filtered = true;
                     this.getExcludedProviders().add( normalized );
                     this.getProject().log( Messages.getMessage( "providerExclusion", resource.toExternalForm(),
                                                                 line.trim() ), Project.MSG_DEBUG );
 
                 }
             }
 
             reader.close();
             reader = null;
             in = null;
 
             if ( filtered )
             {
                 final File tmpResource = File.createTempFile( this.getClass().getName(), ".rsrc" );
                 this.temporaryResources.add( tmpResource );
 
                 out = new FileOutputStream( tmpResource );
                 writer = new BufferedWriter( new OutputStreamWriter( out, "UTF-8" ) );
 
                 for ( final String line : filteredLines )
                 {
                     writer.write( line );
                     writer.newLine();
                 }
 
                 writer.close();
                 writer = null;
                 out = null;
 
                 filteredResource = tmpResource.toURI().toURL();
             }
 
             return filteredResource;
         }
         finally
         {
             try
             {
                 if ( reader != null )
                 {
                     reader.close();
                 }
             }
             catch ( final IOException e )
             {
                 this.project.log( Messages.getMessage( e ), e, Project.MSG_ERR );
             }
             finally
             {
                 try
                 {
                     if ( in != null )
                     {
                         in.close();
                     }
                 }
                 catch ( final IOException e )
                 {
                     this.project.log( Messages.getMessage( e ), e, Project.MSG_ERR );
                 }
                 finally
                 {
                     try
                     {
                         if ( writer != null )
                         {
                             writer.close();
                         }
                     }
                     catch ( final IOException e )
                     {
                         this.project.log( Messages.getMessage( e ), e, Project.MSG_ERR );
                     }
                     finally
                     {
                         try
                         {
                             if ( out != null )
                             {
                                 out.close();
                             }
                         }
                         catch ( final IOException e )
                         {
                             this.project.log( Messages.getMessage( e ), e, Project.MSG_ERR );
                         }
                     }
                 }
             }
         }
     }
 
     private URL filterModlets( final URL resource ) throws ModelException, IOException, JAXBException
     {
         InputStream in = null;
 
         try
         {
             URL filteredResource = resource;
             in = resource.openStream();
 
             final ModelContext modelContext = ModelContextFactory.newInstance().newModelContext();
             final JAXBElement<?> e =
                 (JAXBElement<?>) modelContext.createUnmarshaller( ModletObject.MODEL_PUBLIC_ID ).unmarshal( in );
 
             in.close();
             in = null;
 
             final Object o = e.getValue();
             Modlets modlets = null;
             boolean filtered = false;
 
             if ( o instanceof Modlets )
             {
                 modlets = (Modlets) o;
             }
             else if ( o instanceof Modlet )
             {
                 modlets = new Modlets();
                 modlets.getModlet().add( (Modlet) o );
             }
 
             if ( modlets != null )
             {
                 for ( final Iterator<Modlet> it = modlets.getModlet().iterator(); it.hasNext(); )
                 {
                     final Modlet m = it.next();
 
                     if ( this.getModletExcludes().contains( m.getName() ) )
                     {
                         it.remove();
                         filtered = true;
                         this.addExcludedModlet( m );
                         this.getProject().log( Messages.getMessage( "modletExclusion", resource.toExternalForm(),
                                                                     m.getName() ), Project.MSG_DEBUG );
 
                         continue;
                     }
 
                     if ( this.filterModlet( m, resource.toExternalForm() ) )
                     {
                         filtered = true;
                     }
                 }
 
                 if ( filtered )
                 {
                     final File tmpResource = File.createTempFile( this.getClass().getName(), ".rsrc" );
                     this.temporaryResources.add( tmpResource );
                     modelContext.createMarshaller( ModletObject.MODEL_PUBLIC_ID ).marshal(
                         new ObjectFactory().createModlets( modlets ), tmpResource );
 
                     filteredResource = tmpResource.toURI().toURL();
                 }
             }
 
             return filteredResource;
         }
         finally
         {
             try
             {
                 if ( in != null )
                 {
                     in.close();
                 }
             }
             catch ( final IOException e )
             {
                 this.project.log( Messages.getMessage( e ), e, Project.MSG_ERR );
             }
         }
     }
 
     private boolean filterModlet( final Modlet modlet, final String resourceInfo )
     {
         boolean filteredSchemas = false;
         boolean filteredServices = false;
 
         if ( modlet.getSchemas() != null )
         {
             final Schemas schemas = new Schemas();
 
             for ( final Schema s : modlet.getSchemas().getSchema() )
             {
                 if ( !this.getSchemaExcludes().contains( s.getPublicId() ) )
                 {
                     schemas.getSchema().add( s );
                 }
                 else
                 {
                     this.getProject().log( Messages.getMessage( "schemaExclusion", resourceInfo, s.getPublicId() ),
                                            Project.MSG_DEBUG );
 
                     this.addExcludedSchema( s );
                     filteredSchemas = true;
                 }
             }
 
             if ( filteredSchemas )
             {
                 modlet.setSchemas( schemas );
             }
         }
 
         if ( modlet.getServices() != null )
         {
             final Services services = new Services();
 
             for ( final Service s : modlet.getServices().getService() )
             {
                 if ( !this.getServiceExcludes().contains( s.getClazz() ) )
                 {
                     services.getService().add( s );
                 }
                 else
                 {
                     this.getProject().log( Messages.getMessage( "serviceExclusion", resourceInfo, s.getClazz() ),
                                            Project.MSG_DEBUG );
 
                     this.addExcludedService( s );
                     filteredServices = true;
                 }
             }
 
             if ( filteredServices )
             {
                 modlet.setServices( services );
             }
         }
 
         return filteredSchemas || filteredServices;
     }
 
     private synchronized void addExcludedModlet( final Modlet modlet )
     {
         try
         {
             final Modlet m = this.getExcludedModlets().getModlet( modlet.getName() );
 
             if ( m != null )
             {
                 if ( m.getVersion() != null && modlet.getVersion() != null
                          && VersionParser.compare( m.getVersion(), modlet.getVersion() ) < 0 )
                 {
                     this.getExcludedModlets().getModlet().remove( m );
                     this.getExcludedModlets().getModlet().add( modlet );
                 }
             }
             else
             {
                 this.getExcludedModlets().getModlet().add( modlet );
             }
         }
         catch ( final ParseException e )
         {
             this.getProject().log( Messages.getMessage( e ), e, Project.MSG_WARN );
         }
         catch ( final TokenMgrError e )
         {
             this.getProject().log( Messages.getMessage( e ), e, Project.MSG_WARN );
         }
     }
 
     private synchronized void addExcludedSchema( final Schema schema )
     {
         if ( this.getExcludedSchemas().getSchemaBySystemId( schema.getSystemId() ) == null )
         {
             this.getExcludedSchemas().getSchema().add( schema );
         }
     }
 
     private synchronized void addExcludedService( final Service service )
     {
         for ( int i = 0, s0 = this.getExcludedServices().getService().size(); i < s0; i++ )
         {
             final Service s = this.getExcludedServices().getService().get( i );
 
             if ( s.getIdentifier().equals( service.getIdentifier() ) && s.getClazz().equals( service.getClazz() ) )
             {
                 return;
             }
         }
 
         this.getExcludedServices().getService().add( service );
     }
 
     private static Set<String> readDefaultExcludes( final String location ) throws IOException
     {
         InputStream in = null;
         BufferedReader reader = null;
         final Set<String> defaultExcludes = new HashSet<String>();
 
         try
         {
             in = ProjectClassLoader.class.getResourceAsStream( location );
             assert in != null : "Expected resource '" + location + "' not found.";
             reader = new BufferedReader( new InputStreamReader( in, "UTF-8" ) );
 
             for ( String line = reader.readLine(); line != null; line = reader.readLine() )
             {
                 final String normalized = line.trim();
 
                 if ( normalized.length() > 0 && !normalized.contains( "#" ) )
                 {
                     defaultExcludes.add( line.trim() );
                 }
             }
 
             reader.close();
             reader = null;
             in = null;
 
             return Collections.unmodifiableSet( defaultExcludes );
         }
         finally
         {
             try
             {
                 if ( reader != null )
                 {
                     reader.close();
                 }
             }
             catch ( final IOException e )
             {
                 // Suppressed.
             }
             finally
             {
                 try
                 {
                     if ( in != null )
                     {
                         in.close();
                     }
                 }
                 catch ( final IOException e )
                 {
                     // Suppressed.
                 }
             }
         }
     }
 
 }