public ProcessSelectionPage(Map<String, Object> input) { super("process selection"); this.input = input; processFactories = Processors.getProcessFactories(); selectedFactory = null; }
/** * Look up a Factory by name of a process it supports. * * @param name Name of the Process you wish to work with * @return ProcessFactory capable of creating an instanceof the named process */ public static synchronized ProcessFactory createProcessFactory(Name name) { // store a local reference to last factory, since it could change if this method is called // within the factories getNames() method, which could happen if a factory delegates in some // way ProcessFactory last = lastFactory; if (last != null && last.getNames().contains(name)) { return last; } for (ProcessFactory factory : getProcessFactories()) { if (factory.getNames().contains(name)) { lastFactory = factory; return factory; } } return null; // go fish }
new ArrayList<ProcessFactory>(Processors.getProcessFactories()); Collections.sort(factories, FACTORY_COMPARATOR);
public ProcessSelectionPage(Map<String, Object> input) { super("process selection"); this.input = input; processFactories = Processors.getProcessFactories(); selectedFactory = null; }
public ProcessSelectionPage( Map<String, Object> input ) { super("process selection"); this.input = input; processFactories = Processors.getProcessFactories(); selectedFactory = null; }
/** * Set of available ProcessFactory, each eventually wrapped or filtered out by the registered * {@link ProcessFilter} * * @return Set of ProcessFactory */ public static Set<ProcessFactory> getProcessFactories() { Set<ProcessFactory> factories = Processors.getProcessFactories(); Set<ProcessFactory> result = new LinkedHashSet<ProcessFactory>(); // scan filters and let them wrap and exclude as necessary for (ProcessFactory pf : factories) { pf = applyFilters(pf); if (pf != null) { result.add(pf); } } return result; }
/** * Returns the process factory instance corresponding to the specified class. * * @param factoryClass The factory to look for * @param applyFilters Whether to apply the registered {@link ProcessFilter} instances, or not */ public static ProcessFactory getProcessFactory(Class factoryClass, boolean applyFilters) { Set<ProcessFactory> factories = Processors.getProcessFactories(); for (ProcessFactory pf : factories) { if (factoryClass.equals(pf.getClass())) { if (!applyFilters) { return pf; } else { // scan filters and let them wrap as necessary pf = applyFilters(pf); return pf; } } } // not found return null; } }
/** * Look up a Factory by name of a process it supports. * * @param name Name of the Process you wish to work with * @return ProcessFactory capable of creating an instanceof the named process */ public static synchronized ProcessFactory createProcessFactory(Name name){ if( lastFactory != null && lastFactory.getNames().contains(name)){ return lastFactory; } for( ProcessFactory factory : getProcessFactories() ) { if(factory.getNames().contains(name)) { lastFactory = factory; return factory; } } return null; // go fish }
new ArrayList<ProcessFactory>(Processors.getProcessFactories());
private void processDescriptionAll() { for (ProcessFactory pf : Processors.getProcessFactories()) { for (Name processName : pf.getNames()) { if (false == this.dataTransformer.isTransmutable(pf, processName)) { continue; } this.processDescription(pf, processName); } } }
private synchronized void init() { if(functionNames == null) { // collect and sort the factories to have a reproducable list of function names List<ProcessFactory> factories = new ArrayList<ProcessFactory>(Processors .getProcessFactories()); Collections.sort(factories, FACTORY_COMPARATOR); // collect name and params of all processes resulting in a single output processToFunction = new HashMap<Name,FunctionName>(); functionNames = new ArrayList<FunctionName>(); for (ProcessFactory factory : factories) { for (Name processName : factory.getNames()) { Map<String, Parameter<?>> resultInfo = factory.getResultInfo(processName, null); // check there is a single output if(getPrimary(resultInfo) != null) { Map<String, Parameter<?>> parameterInfo = factory.getParameterInfo(processName); List<String> argumentNames = new ArrayList<String>(parameterInfo.keySet()); FunctionName functionName = new FunctionNameImpl(processName, argumentNames); functionNames.add(functionName); processToFunction.put(processName, functionName); } } } // add the parameter function functionNames.add(new FunctionNameImpl(ParameterFunction.NAME, -1)); } }
for (ProcessFactory pf : Processors.getProcessFactories()) { int count = 0; for (Name name : pf.getNames()) {
processBlacklist.clear(); for (ProcessFactory pf : Processors.getProcessFactories()) { int count = 0; for (Name name : pf.getNames()) {
public void testNamesUnique() throws Exception { List<String> procs = new ArrayList<String>(); Set<String> uniqueProcs = new HashSet<String>(); for (ProcessFactory pf : Processors.getProcessFactories()) { for (Name name : pf.getNames()) { String procName = name.getURI(); procs.add(procName); uniqueProcs.add(procName); } } // remove duplicate names removeSingle(procs, uniqueProcs); if (procs.size() > 0) { System.out.println("Duplicate process names: " + procs); } assertTrue(procs.size() == 0); }
for (ProcessFactory pf : Processors.getProcessFactories()) { for (Name name : pf.getNames()) { if (!getProcessBlacklist().contains(name)) {