common/src/main/java/org/apache/abdera2/common/Discover.java - abdera - Git at Google

 /*
  * Licensed to the Apache Software Foundation (ASF) under one or more
  * contributor license agreements.  The ASF licenses this file to You
  * 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.  For additional information regarding
  * copyright in this work, please see the NOTICE file in the top level
  * directory of this distribution.
  */
 package org.apache.abdera2.common;

 import java.io.BufferedReader;
 import java.io.IOException;
 import java.io.InputStream;
 import java.io.InputStreamReader;
 import java.net.URL;
 import java.util.Enumeration;
 import java.util.HashSet;
 import java.util.Iterator;
 import java.util.LinkedHashSet;
 import java.util.Set;

 import org.apache.abdera2.common.anno.AnnoUtil;
 import org.apache.abdera2.common.misc.MultiIterator;
 import org.apache.commons.logging.Log;
 import org.apache.commons.logging.LogFactory;

 @SuppressWarnings("unchecked")
 public final class Discover {

     private final static Log log = LogFactory.getLog(Discover.class);
     private Discover() {}

     public static <T> T locate(Class<T> _class, String defaultImpl, Object... args) {
         return (T)locate(_class, defaultImpl, getLoader(), args);
     }

     public static <T> T locate(String id, String defaultImpl, Object... args) {
         return (T)locate(id, defaultImpl, getLoader(), args);
     }

     public static <T> T locate(Class<T> _class, String defaultImpl, ClassLoader loader, Object... args) {
       try {
         T instance = null, first = null;
         Iterable<T> items =
           locate(_class, loader, args);
         Iterator<T> is = items.iterator();
         if (defaultImpl == null)
           defaultImpl = AnnoUtil.getDefaultImplementation(_class);
         while (instance == null && is.hasNext()) {
           T i = is.next();
           if (defaultImpl != null && defaultImpl.equals(i.getClass().getName())) {
             instance = i;
             break;
           } else if (first == null)
             first = i;
         }
         instance = instance != null ? instance : first;
         return instance != null ?
           instance :
           (T)load(loader, defaultImpl, false, args);
       } catch (Throwable t) {
           throw new RuntimeException(t);
       }
     }

     public static <T> T locate(String id, String defaultImpl, ClassLoader loader, Object... args) {
         try {
             T instance = null;
             Iterable<T> items =
               locate(id, loader, args);
             for (T i : items) {
                 instance = i;
                 break;
             }
             return instance != null ?
               instance :
               (T)load(loader, defaultImpl, false, args);
         } catch (Throwable t) {
             throw new RuntimeException(t);
         }
     }

     private static ClassLoader getLoader() {
         return Thread.currentThread().getContextClassLoader();
     }

     public static <T> Iterable<T> locate(Class<T> _class, ClassLoader cl, Object... args) {
         return locate(_class, false, cl, args);
     }

     public static <T> Iterable<T> locate(String id, ClassLoader cl, Object... args) {
         return locate(id, false, cl, args);
     }

     public static <T> Iterable<T> locate(Class<T> _class, boolean classesonly, ClassLoader cl, Object... args) {
       return locate(_class, classesonly, new DefaultLoader<T>(_class, classesonly, args, cl));
     }

     public static <T> Iterable<T> locate(String id, boolean classesonly, ClassLoader cl, Object... args) {
         return locate(id, classesonly, new DefaultLoader<T>(id, classesonly, args, cl));
     }

     public static <T> Iterable<T> locate(Class<T> _class, Object...args) {
       return locate(_class, false, args);
     }

     public static <T> Iterable<T> locate(String id, Object... args) {
         return locate(id, false, args);
     }

     public static <T> Iterable<T> locate(Class<T> _class, boolean classesonly, Object... args) {
       return locate(new DefaultLoader<T>(_class, classesonly, args));
     }

     public static <T> Iterable<T> locate(String id, boolean classesonly, Object... args) {
         return locate(new DefaultLoader<T>(id, classesonly, args));
     }

     public static <T> Iterable<T> locate(Iterable<T> loader) {
         Set<T> impls = new LinkedHashSet<T>();
         try {
             for (T instance : loader) {
               if (instance != null)
                 impls.add(instance);
             }
         } catch (Throwable t) {
             log.error(t);
         }
         return impls;
     }

     public static class DefaultLoader<T> implements Iterable<T> {
         protected final ClassLoader loader;
         protected final String id;
         protected final Iterator<T> iterator;
         protected final Object[] args;

         public DefaultLoader(String id, boolean classesonly, Object[] args) {
             this(id, classesonly, args, getLoader());
         }

         public DefaultLoader(String id, boolean classesonly, Object[] args, ClassLoader loader) {
             this.loader = loader != null ? loader : getLoader();
             this.id = id;
             this.args = args;
             this.iterator = init(classesonly);
         }

         public DefaultLoader(Class<T> _class, boolean classesonly, Object[] args, ClassLoader loader) {
           this(_class.getName(), classesonly, args, loader);
         }

         public DefaultLoader(Class<T> _class, boolean classesonly, Object[] args) {
           this(_class.getName(), classesonly, args);
         }

         private Iterator<T> init(boolean classesonly) {
             try {
                 Set<Iterator<T>> list = new HashSet<Iterator<T>>();
                 Enumeration<URL> e = locateResources("META-INF/services/" + id, //$NON-NLS-1$
                                                      loader,
                                                      Discover.class);
                 while (e.hasMoreElements()) {
                     Iterator<T> i =
                         new DefaultLoaderIterator<T>(loader, e.nextElement().openStream(), classesonly, args);
                     list.add(i);
                 }
                 return new MultiIterator<T>(list);
             } catch (Throwable t) {
                 throw new RuntimeException(t);
             }
         }

         public Iterator<T> iterator() {
             return iterator;
         }
     }

     public static class DefaultLoaderIterator<T> extends LineReaderLoaderIterator<T> {
         public DefaultLoaderIterator(ClassLoader cl, InputStream in, boolean classesonly, Object[] args) {
             super(cl, in, classesonly, args);
         }

         public T next() {
             try {
                 if (!hasNext())
                     return null;
                 return create(read(), args);
             } catch (Throwable t) {
                 return null;
             }
         }

         protected T create(String spec, Object[] args) {
             try {
                 return (T)load(cl, spec, classesonly, args);
             } catch (RuntimeException e) {
                 throw e;
             } catch (Throwable t) {
                 throw new RuntimeException(t);
             }
         }
     }

     private static <T> T load(ClassLoader loader, String spec, boolean classesonly, Object[] args) throws Exception {
         if (classesonly) {
             return (T)getClass(loader, spec);
         } else {
             Class<T> _class = getClass(loader, spec);
             Class<?>[] types = new Class<?>[args != null ? args.length : 0];
             if (args != null) {
                 for (int n = 0; n < args.length; n++) {
                     types[n] = args[n].getClass();
                 }
                 return _class.getConstructor(types).newInstance(args);
             } else {
                 return _class.newInstance();
             }
         }
     }

     private static <T> Class<T> getClass(ClassLoader loader, String spec) {
         Class<T> c = null;
         try {
             c = (Class<T>)loader.loadClass(spec);
         } catch (ClassNotFoundException e) {
             try {
                 // try loading the class from the Discover class loader
                 // if the loader failed.
                 c = (Class<T>)Discover.class.getClassLoader().loadClass(spec);
             } catch (ClassNotFoundException e1) {
                 // throw the original exception
                 throw new RuntimeException(e);
             }
         }
         return c;
     }

     public static abstract class LineReaderLoaderIterator<T> extends LoaderIterator<T> {
         private BufferedReader buf = null;
         private String line = null;
         protected final Object[] args;
         protected final boolean classesonly;

         protected LineReaderLoaderIterator(ClassLoader cl, InputStream in, boolean classesonly, Object[] args) {
             super(cl);
             this.args = args;
             this.classesonly = classesonly;
             try {
                 InputStreamReader reader = new InputStreamReader(in, "UTF-8");
                 buf = new BufferedReader(reader);
                 line = readNext();
             } catch (Throwable t) {
                 throw new RuntimeException(t);
             }
         }

         public boolean hasNext() {
             return line != null;
         }

         protected String readNext() {
             try {
                 String line = null;
                 while ((line = buf.readLine()) != null) {
                     line = line.trim();
                     if (!line.startsWith("#"))break; //$NON-NLS-1$
                 }
                 return line;
             } catch (Throwable t) {
                 throw new RuntimeException(t);
             }
         }

         protected String read() {
             String val = line;
             line = readNext();
             return val;
         }
     }

     public static abstract class LoaderIterator<T> implements Iterator<T> {
         protected final ClassLoader cl;

         protected LoaderIterator(ClassLoader cl) {
             this.cl = cl;
         }

         public void remove() {
         }
     }

     public static URL locateResource(String id, ClassLoader loader, Class<?> callingClass) {
         URL url = loader.getResource(id);
         if (url == null && id.startsWith("/"))
             url = loader.getResource(id.substring(1));
         if (url == null)
             url = locateResource(id, Discover.class.getClassLoader(), callingClass);
         if (url == null && callingClass != null)
             url = locateResource(id, callingClass.getClassLoader(), null);
         if (url == null) {
             url = callingClass.getResource(id);
         }
         if ((url == null) && id.startsWith("/")) {
             url = callingClass.getResource(id.substring(1));
         }
         return url;
     }

     public static Enumeration<URL> locateResources(String id, ClassLoader loader, Class<?> callingClass)
         throws IOException {
         Enumeration<URL> urls = loader.getResources(id);
         if (urls == null && id.startsWith("/"))
             urls = loader.getResources(id.substring(1));
         if (urls == null)
             urls = locateResources(id, Discover.class.getClassLoader(), callingClass);
         if (urls == null)
             urls = locateResources(id, callingClass.getClassLoader(), callingClass);
         return urls;
     }

     public static InputStream locateResourceAsStream(String resourceName, ClassLoader loader, Class<?> callingClass) {
         URL url = locateResource(resourceName, loader, callingClass);
         try {
             return (url != null) ? url.openStream() : null;
         } catch (IOException e) {
             return null;
         }
     }
 }
	/*
	* Licensed to the Apache Software Foundation (ASF) under one or more
	* contributor license agreements. The ASF licenses this file to You
	* 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. For additional information regarding
	* copyright in this work, please see the NOTICE file in the top level
	* directory of this distribution.
	*/
	package org.apache.abdera2.common;

	import java.io.BufferedReader;
	import java.io.IOException;
	import java.io.InputStream;
	import java.io.InputStreamReader;
	import java.net.URL;
	import java.util.Enumeration;
	import java.util.HashSet;
	import java.util.Iterator;
	import java.util.LinkedHashSet;
	import java.util.Set;

	import org.apache.abdera2.common.anno.AnnoUtil;
	import org.apache.abdera2.common.misc.MultiIterator;
	import org.apache.commons.logging.Log;
	import org.apache.commons.logging.LogFactory;

	@SuppressWarnings("unchecked")
	public final class Discover {

	private final static Log log = LogFactory.getLog(Discover.class);
	private Discover() {}

	public static <T> T locate(Class<T> _class, String defaultImpl, Object... args) {
	return (T)locate(_class, defaultImpl, getLoader(), args);
	}

	public static <T> T locate(String id, String defaultImpl, Object... args) {
	return (T)locate(id, defaultImpl, getLoader(), args);
	}

	public static <T> T locate(Class<T> _class, String defaultImpl, ClassLoader loader, Object... args) {
	try {
	T instance = null, first = null;
	Iterable<T> items =
	locate(_class, loader, args);
	Iterator<T> is = items.iterator();
	if (defaultImpl == null)
	defaultImpl = AnnoUtil.getDefaultImplementation(_class);
	while (instance == null && is.hasNext()) {
	T i = is.next();
	if (defaultImpl != null && defaultImpl.equals(i.getClass().getName())) {
	instance = i;
	break;
	} else if (first == null)
	first = i;
	}
	instance = instance != null ? instance : first;
	return instance != null ?
	instance :
	(T)load(loader, defaultImpl, false, args);
	} catch (Throwable t) {
	throw new RuntimeException(t);
	}
	}

	public static <T> T locate(String id, String defaultImpl, ClassLoader loader, Object... args) {
	try {
	T instance = null;
	Iterable<T> items =
	locate(id, loader, args);
	for (T i : items) {
	instance = i;
	break;
	}
	return instance != null ?
	instance :
	(T)load(loader, defaultImpl, false, args);
	} catch (Throwable t) {
	throw new RuntimeException(t);
	}
	}

	private static ClassLoader getLoader() {
	return Thread.currentThread().getContextClassLoader();
	}

	public static <T> Iterable<T> locate(Class<T> _class, ClassLoader cl, Object... args) {
	return locate(_class, false, cl, args);
	}

	public static <T> Iterable<T> locate(String id, ClassLoader cl, Object... args) {
	return locate(id, false, cl, args);
	}

	public static <T> Iterable<T> locate(Class<T> _class, boolean classesonly, ClassLoader cl, Object... args) {
	return locate(_class, classesonly, new DefaultLoader<T>(_class, classesonly, args, cl));
	}

	public static <T> Iterable<T> locate(String id, boolean classesonly, ClassLoader cl, Object... args) {
	return locate(id, classesonly, new DefaultLoader<T>(id, classesonly, args, cl));
	}

	public static <T> Iterable<T> locate(Class<T> _class, Object...args) {
	return locate(_class, false, args);
	}

	public static <T> Iterable<T> locate(String id, Object... args) {
	return locate(id, false, args);
	}

	public static <T> Iterable<T> locate(Class<T> _class, boolean classesonly, Object... args) {
	return locate(new DefaultLoader<T>(_class, classesonly, args));
	}

	public static <T> Iterable<T> locate(String id, boolean classesonly, Object... args) {
	return locate(new DefaultLoader<T>(id, classesonly, args));
	}

	public static <T> Iterable<T> locate(Iterable<T> loader) {
	Set<T> impls = new LinkedHashSet<T>();
	try {
	for (T instance : loader) {
	if (instance != null)
	impls.add(instance);
	}
	} catch (Throwable t) {
	log.error(t);
	}
	return impls;
	}

	public static class DefaultLoader<T> implements Iterable<T> {
	protected final ClassLoader loader;
	protected final String id;
	protected final Iterator<T> iterator;
	protected final Object[] args;

	public DefaultLoader(String id, boolean classesonly, Object[] args) {
	this(id, classesonly, args, getLoader());
	}

	public DefaultLoader(String id, boolean classesonly, Object[] args, ClassLoader loader) {
	this.loader = loader != null ? loader : getLoader();
	this.id = id;
	this.args = args;
	this.iterator = init(classesonly);
	}

	public DefaultLoader(Class<T> _class, boolean classesonly, Object[] args, ClassLoader loader) {
	this(_class.getName(), classesonly, args, loader);
	}

	public DefaultLoader(Class<T> _class, boolean classesonly, Object[] args) {
	this(_class.getName(), classesonly, args);
	}

	private Iterator<T> init(boolean classesonly) {
	try {
	Set<Iterator<T>> list = new HashSet<Iterator<T>>();
	Enumeration<URL> e = locateResources("META-INF/services/" + id, //$NON-NLS-1$
	loader,
	Discover.class);
	while (e.hasMoreElements()) {
	Iterator<T> i =
	new DefaultLoaderIterator<T>(loader, e.nextElement().openStream(), classesonly, args);
	list.add(i);
	}
	return new MultiIterator<T>(list);
	} catch (Throwable t) {
	throw new RuntimeException(t);
	}
	}

	public Iterator<T> iterator() {
	return iterator;
	}
	}

	public static class DefaultLoaderIterator<T> extends LineReaderLoaderIterator<T> {
	public DefaultLoaderIterator(ClassLoader cl, InputStream in, boolean classesonly, Object[] args) {
	super(cl, in, classesonly, args);
	}

	public T next() {
	try {
	if (!hasNext())
	return null;
	return create(read(), args);
	} catch (Throwable t) {
	return null;
	}
	}

	protected T create(String spec, Object[] args) {
	try {
	return (T)load(cl, spec, classesonly, args);
	} catch (RuntimeException e) {
	throw e;
	} catch (Throwable t) {
	throw new RuntimeException(t);
	}
	}
	}

	private static <T> T load(ClassLoader loader, String spec, boolean classesonly, Object[] args) throws Exception {
	if (classesonly) {
	return (T)getClass(loader, spec);
	} else {
	Class<T> _class = getClass(loader, spec);
	Class<?>[] types = new Class<?>[args != null ? args.length : 0];
	if (args != null) {
	for (int n = 0; n < args.length; n++) {
	types[n] = args[n].getClass();
	}
	return _class.getConstructor(types).newInstance(args);
	} else {
	return _class.newInstance();
	}
	}
	}

	private static <T> Class<T> getClass(ClassLoader loader, String spec) {
	Class<T> c = null;
	try {
	c = (Class<T>)loader.loadClass(spec);
	} catch (ClassNotFoundException e) {
	try {
	// try loading the class from the Discover class loader
	// if the loader failed.
	c = (Class<T>)Discover.class.getClassLoader().loadClass(spec);
	} catch (ClassNotFoundException e1) {
	// throw the original exception
	throw new RuntimeException(e);
	}
	}
	return c;
	}

	public static abstract class LineReaderLoaderIterator<T> extends LoaderIterator<T> {
	private BufferedReader buf = null;
	private String line = null;
	protected final Object[] args;
	protected final boolean classesonly;

	protected LineReaderLoaderIterator(ClassLoader cl, InputStream in, boolean classesonly, Object[] args) {
	super(cl);
	this.args = args;
	this.classesonly = classesonly;
	try {
	InputStreamReader reader = new InputStreamReader(in, "UTF-8");
	buf = new BufferedReader(reader);
	line = readNext();
	} catch (Throwable t) {
	throw new RuntimeException(t);
	}
	}

	public boolean hasNext() {
	return line != null;
	}

	protected String readNext() {
	try {
	String line = null;
	while ((line = buf.readLine()) != null) {
	line = line.trim();
	if (!line.startsWith("#"))break; //$NON-NLS-1$
	}
	return line;
	} catch (Throwable t) {
	throw new RuntimeException(t);
	}
	}

	protected String read() {
	String val = line;
	line = readNext();
	return val;
	}
	}

	public static abstract class LoaderIterator<T> implements Iterator<T> {
	protected final ClassLoader cl;

	protected LoaderIterator(ClassLoader cl) {
	this.cl = cl;
	}

	public void remove() {
	}
	}

	public static URL locateResource(String id, ClassLoader loader, Class<?> callingClass) {
	URL url = loader.getResource(id);
	if (url == null && id.startsWith("/"))
	url = loader.getResource(id.substring(1));
	if (url == null)
	url = locateResource(id, Discover.class.getClassLoader(), callingClass);
	if (url == null && callingClass != null)
	url = locateResource(id, callingClass.getClassLoader(), null);
	if (url == null) {
	url = callingClass.getResource(id);
	}
	if ((url == null) && id.startsWith("/")) {
	url = callingClass.getResource(id.substring(1));
	}
	return url;
	}

	public static Enumeration<URL> locateResources(String id, ClassLoader loader, Class<?> callingClass)
	throws IOException {
	Enumeration<URL> urls = loader.getResources(id);
	if (urls == null && id.startsWith("/"))
	urls = loader.getResources(id.substring(1));
	if (urls == null)
	urls = locateResources(id, Discover.class.getClassLoader(), callingClass);
	if (urls == null)
	urls = locateResources(id, callingClass.getClassLoader(), callingClass);
	return urls;
	}

	public static InputStream locateResourceAsStream(String resourceName, ClassLoader loader, Class<?> callingClass) {
	URL url = locateResource(resourceName, loader, callingClass);
	try {
	return (url != null) ? url.openStream() : null;
	} catch (IOException e) {
	return null;
	}
	}
	}