/*
* GeoTools - The Open Source Java GIS Toolkit
* http://geotools.org
*
* (C) 2008, Open Source Geospatial Foundation (OSGeo)
*
* 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;
* version 2.1 of the License.
*
* 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.
*/
package org.geotools.process;
import java.util.Arrays;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.Callable;
import java.util.concurrent.Executors;
import java.util.concurrent.ThreadFactory;
import org.geotools.factory.FactoryCreator;
import org.geotools.factory.FactoryFinder;
import org.geotools.factory.FactoryRegistry;
import org.geotools.resources.LazySet;
import org.geotools.util.NullProgressListener;
import org.opengis.feature.type.Name;
/**
* Factory and utility methods for {@link ProcessExecutor}, and {@link Process}
* classes defined in this package.
* <p>
* Defines static methods used to access the application's default process factory implementations.
*
* @author gdavis
*
* @source $URL$
*/
public class Processors extends FactoryFinder {
/**
* The service registry for this manager. Will be initialized only when first needed.
*/
private static FactoryRegistry registry;
/**
* Do not allow any instantiation of this class.
*/
private Processors() {
// singleton
}
/**
* Returns the service registry. The registry will be created the first
* time this method is invoked.
*/
private static FactoryRegistry getServiceRegistry() {
synchronized (Processors.class) {
if (registry == null) {
registry = new FactoryCreator(Arrays.asList(new Class<?>[]{ProcessFactory.class}));
}
}
return registry;
}
/**
* Set of available ProcessFactory.
*
* @return Set of ProcessFactory
*/
public static Set<ProcessFactory> getProcessFactories() {
return new LazySet<ProcessFactory>(getServiceRegistry().getServiceProviders(
ProcessFactory.class, null, null));
}
/**
* Look up a Factory by name.
*
* @param name Name of Factory
* @return ProcessFactory with matching name
*/
public static synchronized ProcessFactory createProcessFactory(Name name){
for( ProcessFactory factory : getProcessFactories() ) {
if(factory.getNames().contains(name)) {
return factory;
}
}
return null; // go fish
}
/**
* Look up an implementation of the named process on the classpath.
*/
public static synchronized Process createProcess(Name name){
ProcessFactory factory = createProcessFactory( name );
if( factory == null ) return null;
return factory.create(name);
}
/**
* Used to wrap a Process up as a Callable for use with an existing ExecutorService
*/
public static Callable<Map<String,Object>> createCallable( final Process process, final Map<String,Object> input ){
return new Callable<Map<String,Object>>(){
public Map<String, Object> call() throws Exception {
return process.execute( input, new CallableProgressListener() );
}
};
}
public static ProcessExecutor newProcessExecutor( int nThreads, ThreadFactory threadFactory ){
if( threadFactory == null ) threadFactory = Executors.defaultThreadFactory();
return new ThreadPoolProcessExecutor( nThreads, threadFactory);
}
/**
* This progress listener checks if the current Thread is interrupted, it
* acts as a bridge between Future and ProgressListener code.
*
* @author Jody
*/
static class CallableProgressListener extends NullProgressListener {
@Override
public boolean isCanceled() {
return Thread.currentThread().isInterrupted();
}
}
}