Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * Copyright 2010 JBoss Inc
   *
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   *      http://www.apache.org/licenses/LICENSE-2.0
   *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
 
 package org.drools.util;
 
 import java.net.URL;
 import java.util.List;
 import java.util.Map;
This is an Internal Drools Class
 
 public class CompositeClassLoader extends ClassLoader {
     /* Assumption: modifications are really rare, but iterations are frequent. */
     private final List<ClassLoader>       classLoaders = new CopyOnWriteArrayList<ClassLoader>();
     private final AtomicReference<Loaderloader       = new AtomicReference<Loader>();
 
     public CompositeClassLoader() {
         supernull );
         .setnew DefaultLoader() );
     }
     
     public Collection<ClassLoadergetClassLoaders() {
         return Collections.unmodifiableCollectionthis. );
     }
 
     public synchronized void setCachingEnabled(boolean enabled) {
         if ( enabled && .get() instanceof DefaultLoader ) {
             .setnew CachingLoader() );
         } else if ( !enabled && .get() instanceof CachingLoader ) {
             .set. );
         }
     }
 
     public synchronized void addClassLoader(final ClassLoader classLoader) {
         /* NB: we need synchronized here even though we use a COW list:
          *     two threads may try to add the same new class loader, so we need
          *     to protect over a bigger area than just a single iteration.
          */
         // don't add duplicate ClassLoaders;
         for ( final ClassLoader cl : this. ) {
             if ( cl == classLoader ) {
                 return;
             }
         }
         this..add( 0, classLoader );
         this..get().reset();
     }
 
     public synchronized void removeClassLoader(final ClassLoader classLoader) {
         /* synchronized to protect against concurrent runs of 
          * addClassLoader(x) and removeClassLoader(x).
          */
         .removeclassLoader );
         this..get().reset();
     }

    
This ClassLoader never has classes of it's own, so only search the child ClassLoaders and the parent ClassLoader if one is provided
 
     public Class< ? > loadClass(final String name,
                                 final boolean resolvethrows ClassNotFoundException {
         Class cls = .get().loadthis,
                                        name,
                                        resolve );
         if ( cls == null ) {
             throw new ClassNotFoundException"Unable to load class: " + name );
         }
         
         return cls;
     }
    
   
This ClassLoader never has classes of it's own, so only search the child ClassLoaders and the parent ClassLoader if one is provided
   public Class< ? > loadClass(final String name,
                               final boolean resolve,
                               final ClassLoader ignorethrows ClassNotFoundException {
       Class cls = .get().loadthis,
                                      name,
                                      resolve,
                                      ignore );
       if ( cls == null ) {
           throw new ClassNotFoundException"Unable to load class" + name );
       }
       
       return cls;
   }
    
    
This ClassLoader never has classes of it's own, so only search the child ClassLoaders and the parent ClassLoader if one is provided
    public InputStream getResourceAsStream(final String name) {
        for ( final ClassLoader classLoader : this. ) {
            InputStream stream = classLoader.getResourceAsStreamname );
            if ( stream != null ) {
                return stream;
            }
        }
        return null;
    }
    @Override
    public URL getResource(String name) {
        for ( final ClassLoader classLoader : this. ) {
            URL url = classLoader.getResourcename );
            if ( url != null ) {
                return url;
            }
        }
        return null;
    }
    @Override
    public Enumeration<URLgetResources(String namethrows IOException {
        CompositeEnumeration<URLenumerations = new CompositeEnumeration<URL>();
        for ( final ClassLoader classLoader : this. ) {
            Enumeration<URLe = classLoader.getResourcesname );
            if ( e != null ) {
                enumerations.addEnumeratione );
            }
        }
        
        return enumerations;
    }
    public void dumpStats() {
        ..println.toString() );
    }
    private static interface Loader {
        public Class< ? > load(final CompositeClassLoader cl,
                               final String name,
                               final boolean resolve);
        public Class< ? > load(CompositeClassLoader compositeClassLoader,
                               String name,
                               boolean resolve,
                               ClassLoader ignore);
        public void reset();
    }
    private static class DefaultLoader
        implements
        Loader {
        // this class is stateless, so lets make a singleton of it
        public static final DefaultLoader INSTANCE = new DefaultLoader();
        private DefaultLoader() {
        }
        public Class< ? > load(final CompositeClassLoader cl,
                               final String name,
                               final boolean resolve) {
            return load(clnameresolvenull);
        }
        public Class< ? > load(CompositeClassLoader cl,
                               String name,
                               boolean resolve,
                               ClassLoader ignore) {
            // search the child ClassLoaders
            Class< ? > cls = null;
            for ( final ClassLoader classLoader : cl.classLoaders ) {
                if ( classLoader != ignore ) {
                    if ( classLoader instanceof FastClassLoader ) {
                        cls = ((FastClassLoader)classLoader).fastFindClassname );
                    } else {
                        // we ignore a calling classloader, to stop recursion
                        try {
                            cls = Class.forNamename,
                                                 resolve,
                                                 classLoader );
                        } catch ( ClassNotFoundException e ) {
                            // swallow as we need to check more classLoaders
                        }
                    }
                    if ( cls != null ) {
                        break;
                    }
                }
            }
            return cls;
        }
        
        public void reset() {
            // nothing to do
        }
    }
    private static class CachingLoader
        implements
        Loader {
        private final Map<StringObjectclassLoaderResultMap = new HashMap<StringObject>();
        public long                       successfulCalls      = 0;
        public long                       failedCalls          = 0;
        public long                       cacheHits            = 0;
        public Class< ? > load(final CompositeClassLoader cl,
                               final String name,
                               final boolean resolve) {
            return load(clnameresolvenull);
        }
        public Class< ? > load(CompositeClassLoader cl,
                               String name,
                               boolean resolve,
                               ClassLoader ignore) {
            if ( .containsKeyname ) ) {
                ++;
                return (Class< ? >) .getname );
            }
            // search the child ClassLoaders
            Class< ? > cls = null;
            for ( final ClassLoader classLoader : cl.classLoaders ) {
                if ( classLoader != ignore ) {
                    if ( classLoader instanceof FastClassLoader ) {
                        cls = ((FastClassLoader)classLoader).fastFindClassname );
                    } else {
                        // we ignore a calling classloader, to stop recursion
                        try {
                            cls = Class.forNamename,
                                                 resolve,
                                                 classLoader );
                        } catch ( ClassNotFoundException e ) {
                            // swallow as we need to check more classLoaders
                        }
                    }
                    if ( cls != null ) {
                        break;
                    }
                }
            }
            if ( cls != null ) {
                .putname,
                                          cls );
                
                this.++;
            } else {
                this.++;
            }
            return cls;
        }
        
        public void reset() {
            this..clear();
            this. = this. = this. = 0;
        }
        public String toString() {
            return new StringBuilder().append"TotalCalls: " ).append +  +  ).append" CacheHits: " ).append ).append" successfulCalls: " ).append ).append" FailedCalls: " ).append ).toString();
        }
    }
    private static class CompositeEnumeration<URL>
        implements
        Enumeration<URL> {
        private List<URL>     list;
        private Iterator<URL> it;
        public void addEnumeration(Enumeration<URL> enumeration) {
            if ( !enumeration.hasMoreElements() ) {
                // don't add it, if it's empty
                return;
            }
            if ( this. != null ) {
                throw new IllegalStateException"cannot add more enumerations while iterator" );
            }
            if ( this. == null ) {
                this. = new ArrayList<URL>();
            }
            while ( enumeration.hasMoreElements() ) {
                this..addenumeration.nextElement() );
            }
        }
        public int size() {
            if ( this. == null ) {
                return 0;
            } else {
                return this..size();
            }
        }
        public boolean hasMoreElements() {
            if ( this. == null ) {
                if ( this. == null ) {
                    return false;
                } else {
                    this. = this..iterator();
                }
            }
            return .hasNext();
        }
        public URL nextElement() {
            if ( this. == null ) {
                if ( this. == null ) {
                    throw new NoSuchElementException();
                } else {
                    this. = this..iterator();
                }
            }
            return .next();
        }
    }
    
    public CompositeClassLoader clone() {
        CompositeClassLoader classLoader = new CompositeClassLoader();
        classLoader.classLoaders.addAllthis. );
        if ( this..get() instanceof CachingLoader ) {
            classLoader.setCachingEnabledtrue );
        }
        return classLoader;
    }
New to GrepCode? Check out our FAQ X