diff --git a/modules/library/api/src/main/java/org/geotools/filter/FunctionFactory.java b/modules/library/api/src/main/java/org/geotools/filter/FunctionFactory.java index f2d319e..1dbc6ca 100644 --- a/modules/library/api/src/main/java/org/geotools/filter/FunctionFactory.java +++ b/modules/library/api/src/main/java/org/geotools/filter/FunctionFactory.java @@ -18,6 +18,7 @@ package org.geotools.filter; import java.util.List; +import org.opengis.feature.type.Name; import org.opengis.filter.capability.FunctionName; import org.opengis.filter.expression.Expression; import org.opengis.filter.expression.Function; @@ -41,7 +42,7 @@ public interface FunctionFactory { * @return A list of function names, possibly empty, never null. */ List getFunctionNames(); - + /** * Returns a function with the specified name. * @@ -51,4 +52,15 @@ public interface FunctionFactory { * can not be created. This argument may be {@code null}. */ Function function(String name, List args, Literal fallback); + + /** + * Returns a function with the specified name. + * + * @param name The name of the function + * @param args Variable list of expression arguments for the function. + * @param fallback A fallback literal to use in cases where the function does not exist or + * can not be created. This argument may be {@code null}. + */ + Function function(Name name, List args, Literal fallback); + } diff --git a/modules/library/main/src/main/java/org/geotools/filter/FallbackFunction.java b/modules/library/main/src/main/java/org/geotools/filter/FallbackFunction.java index 3a695cd..5ed0dab 100644 --- a/modules/library/main/src/main/java/org/geotools/filter/FallbackFunction.java +++ b/modules/library/main/src/main/java/org/geotools/filter/FallbackFunction.java @@ -18,6 +18,7 @@ package org.geotools.filter; import java.util.List; +import org.opengis.feature.type.Name; import org.opengis.filter.expression.Literal; /** @@ -39,6 +40,11 @@ public class FallbackFunction extends FunctionExpressionImpl { super(name, fallback); this.setParameters(params); } + + public FallbackFunction(Name name, List params, Literal fallback) { + super(name, fallback); + this.setParameters(params); + } public int getArgCount() { return this.params.size(); diff --git a/modules/library/main/src/main/java/org/geotools/filter/FunctionExpressionImpl.java b/modules/library/main/src/main/java/org/geotools/filter/FunctionExpressionImpl.java index f858237..2872340 100644 --- a/modules/library/main/src/main/java/org/geotools/filter/FunctionExpressionImpl.java +++ b/modules/library/main/src/main/java/org/geotools/filter/FunctionExpressionImpl.java @@ -26,7 +26,9 @@ import java.util.Iterator; import java.util.List; import java.util.Map; +import org.geotools.feature.NameImpl; import org.geotools.filter.capability.FunctionNameImpl; +import org.opengis.feature.type.Name; import org.opengis.filter.capability.FunctionName; import org.opengis.filter.expression.ExpressionVisitor; import org.opengis.filter.expression.Function; @@ -79,13 +81,23 @@ public abstract class FunctionExpressionImpl this.functionName = functionName; } protected FunctionExpressionImpl(String name ){ + this(new NameImpl(name)); + } + protected FunctionExpressionImpl(Name name){ this( name, null ); } /** * Creates a new instance of FunctionExpression */ protected FunctionExpressionImpl(String name, Literal fallback) { - this.name = name; + this(new NameImpl(name), fallback); + } + /** + * Creates a new instance of FunctionExpression + */ + protected FunctionExpressionImpl(Name name, Literal fallback) { + this.functionName = new FunctionNameImpl(name, (Class)null); + this.name = name.getLocalPart(); this.fallback = fallback; params = new ArrayList(); } diff --git a/modules/library/main/src/main/java/org/geotools/filter/FunctionFinder.java b/modules/library/main/src/main/java/org/geotools/filter/FunctionFinder.java index 66d02d2..3d0c3a6 100644 --- a/modules/library/main/src/main/java/org/geotools/filter/FunctionFinder.java +++ b/modules/library/main/src/main/java/org/geotools/filter/FunctionFinder.java @@ -27,6 +27,8 @@ import java.util.logging.Logger; import org.geotools.factory.CommonFactoryFinder; import org.geotools.factory.Hints; +import org.geotools.feature.NameImpl; +import org.opengis.feature.type.Name; import org.opengis.filter.capability.FunctionName; import org.opengis.filter.expression.Function; import org.opengis.filter.expression.Literal; @@ -50,7 +52,7 @@ import org.opengis.filter.expression.Literal; public class FunctionFinder { private static final Logger LOGGER = org.geotools.util.logging.Logging.getLogger("org.geotools.filter"); - private volatile Map functionFactoryCache; + private volatile Map functionFactoryCache; public FunctionFinder(Hints hints) { // currently hints are not used, need help :-P @@ -85,18 +87,31 @@ public class FunctionFinder { * @return FunctioName description, or null if function is not available */ public FunctionName findFunctionDescription(String name ){ + return findFunctionDescription(new NameImpl(name)); + } + /** + * Lookup the FunctionName description. + * @param name Function name; this will need to be an exact match + * @return FunctioName description, or null if function is not available + */ + public FunctionName findFunctionDescription(Name name ){ Set functionFactories = CommonFactoryFinder.getFunctionFactories(null); for (FunctionFactory factory : functionFactories) { List functionNames = factory.getFunctionNames(); for( FunctionName description : functionNames ){ - if( description.getName().equals( name )){ + if( description.getFunctionName().equals( name )){ return description; } } } return null; // not found } + public Function findFunction(String name) { + return findFunction(new NameImpl(name)); + } + + public Function findFunction(Name name) { return findFunction(name, null); } @@ -109,9 +124,34 @@ public class FunctionFinder { * @throws a RuntimeException if an implementation for name could not be found */ public Function findFunction(String name, List parameters){ - return findFunction(name, parameters, null ); + return findFunction(toName(name), parameters); + } + + Name toName(String name) { + if (name.contains(":")) { + String[] split = name.split(":"); + return new NameImpl(split[0], ":", split[1]); + } + else if (name.contains("#")) { + String[] split = name.split("#"); + return new NameImpl(split[0], "#", split[1]); + } + else { + return new NameImpl(name); + } } - + /** + * Look up a function for the provided name. + * + * @param name Function name; this will need to be an exact match + * @param parameters Set of parameters required + * @return Generated function + * @throws a RuntimeException if an implementation for name could not be found + */ + public Function findFunction(Name name, List parameters){ + return findFunction(name, parameters, null ); + } + /** * Look up a function for the provided name, may return a FallbackFunction if * an implementation could not be found. @@ -125,13 +165,31 @@ public class FunctionFinder { * @return Function for the provided name, may be a FallbackFunction if an implementation could not be found */ public Function findFunction(String name, List parameters, Literal fallback) { + return findFunction(new NameImpl(name), parameters, fallback); + } + + /** + * Look up a function for the provided name, may return a FallbackFunction if + * an implementation could not be found. + *

+ * You can create a function to represent an SQL function or a function hosted on + * an external service; the fallback value will be used if you evulate + * by a Java implementation on the classpath. + * @param name Function name; this will need to be an exact match + * @param parameters Set of Expressions to use as function parameters + * @param fallbackValue Literal to use if an implementation could not be found + * @return Function for the provided name, may be a FallbackFunction if an implementation could not be found + */ + public Function findFunction(Name name, List parameters, Literal fallback) { //try name as is Function f = findFunctionInternal(name, parameters, fallback); if (f == null) { //try by trimming "Function" off of name - if (name.endsWith("Function")) { - name = name.substring(0, name.length()-"Function".length()); + if (name.getLocalPart().endsWith("Function")) { + String local = name.getLocalPart(); + local = local.substring(0, local.length()-"Function".length()); + name = new NameImpl(name.getNamespaceURI(), name.getSeparator(), local); f = findFunctionInternal(name, parameters, fallback); } } @@ -148,7 +206,7 @@ public class FunctionFinder { } - Function findFunctionInternal(String name, List parameters, Literal fallback) { + Function findFunctionInternal(Name name, List parameters, Literal fallback) { if (functionFactoryCache == null) { synchronized (this) { if (functionFactoryCache == null) { @@ -173,14 +231,14 @@ public class FunctionFinder { return null; } - private HashMap lookupFunctions() { + private HashMap lookupFunctions() { // get all filter functions via function factory - HashMap result = new HashMap(); + HashMap result = new HashMap(); Set functionFactories = CommonFactoryFinder.getFunctionFactories(null); for (FunctionFactory ff : functionFactories) { for (FunctionName functionName : ff.getFunctionNames()) { - result.put(functionName.getName(), ff); + result.put(functionName.getFunctionName(), ff); } } diff --git a/modules/library/main/src/main/java/org/geotools/filter/capability/FunctionNameImpl.java b/modules/library/main/src/main/java/org/geotools/filter/capability/FunctionNameImpl.java index 796cfb1..c2834bd 100644 --- a/modules/library/main/src/main/java/org/geotools/filter/capability/FunctionNameImpl.java +++ b/modules/library/main/src/main/java/org/geotools/filter/capability/FunctionNameImpl.java @@ -22,6 +22,8 @@ import java.util.Collections; import java.util.List; import java.util.Map; +import org.geotools.feature.NameImpl; +import org.opengis.feature.type.Name; import org.opengis.filter.capability.FunctionName; import org.opengis.filter.expression.Function; import org.opengis.geometry.coordinate.ParametricCurveSurface; @@ -38,54 +40,101 @@ import org.opengis.parameter.Parameter; * @source $URL$ */ public class FunctionNameImpl extends OperatorImpl implements FunctionName { - + + /** function name */ + Name functionName; + /** function arguments */ List> args; /** funtion return */ Parameter ret; - public FunctionNameImpl( String name, int argumentCount ) { - this(name, generateReturn(), generateArguments(argumentCount)); + this(new NameImpl(name), argumentCount); } + public FunctionNameImpl( Name name, int argumentCount ) { + this(name, generateReturn(), generateArguments(argumentCount)); + } + public FunctionNameImpl( String name, String ... argumentsNames ) { + this(new NameImpl(name), argumentsNames); + } + + public FunctionNameImpl( Name name, String ... argumentsNames ) { this(name, argumentsNames.length, Arrays.asList(argumentsNames)); } public FunctionNameImpl( String name, List argumentsNames ) { + this( new NameImpl(name), argumentsNames); + } + + public FunctionNameImpl( Name name, List argumentsNames ) { this( name, argumentsNames.size(), argumentsNames ); } public FunctionNameImpl( String name, int argumentCount, List argumentsNames ) { + this(new NameImpl(name), argumentCount, argumentsNames); + } + + public FunctionNameImpl( Name name, int argumentCount, List argumentsNames ) { this(name, generateReturn(), generateArguments(argumentsNames)); } public FunctionNameImpl( String name, int argumentCount, String ... argumentsNames ) { + this(new NameImpl(name), argumentCount, argumentsNames); + } + + public FunctionNameImpl( Name name, int argumentCount, String ... argumentsNames ) { this(name, argumentCount, Arrays.asList(argumentsNames)); } public FunctionNameImpl( FunctionName copy ) { super( copy ); + this.functionName = copy.getFunctionName(); this.ret = copy.getReturn(); this.args = copy.getArguments(); } - + + public FunctionNameImpl( String name, Class returnType, Parameter... arguments) { + this(new NameImpl(name), returnType, arguments); + } + + public FunctionNameImpl( Name name, Class returnType, Parameter... arguments) { + this(name, parameter(name.getLocalPart(), returnType), Arrays.asList(arguments)); + } + public FunctionNameImpl( String name, Parameter retern, Parameter... arguments) { - this(name, retern, Arrays.asList(arguments)); + this(new NameImpl(name), retern, arguments); } - - public FunctionNameImpl( String name, Class returnType, Parameter... arguments) { - this(name, parameter(name, returnType), Arrays.asList(arguments)); + + public FunctionNameImpl( Name name, Parameter retern, Parameter... arguments) { + this(name, retern, Arrays.asList(arguments)); } - + public FunctionNameImpl( String name, Parameter retern, List> arguments) { - super(name); + this(new NameImpl(name), retern, arguments); + } + + public FunctionNameImpl( Name name, Parameter retern, List> arguments) { + super(name.getLocalPart()); + this.functionName = name; this.ret = retern; this.args = arguments; } - + + @Override + public Name getFunctionName() { + return functionName; + } + + @Override + public String getName() { + //override to use local parse of qualfiied functionName + return getFunctionName().getLocalPart(); + } + public int getArgumentCount() { return args.size(); } diff --git a/modules/library/main/src/main/java/org/geotools/filter/function/DefaultFunctionFactory.java b/modules/library/main/src/main/java/org/geotools/filter/function/DefaultFunctionFactory.java index f9b1ab3..a51ee3a 100644 --- a/modules/library/main/src/main/java/org/geotools/filter/function/DefaultFunctionFactory.java +++ b/modules/library/main/src/main/java/org/geotools/filter/function/DefaultFunctionFactory.java @@ -29,11 +29,13 @@ import java.util.logging.Level; import java.util.logging.Logger; import org.geotools.factory.CommonFactoryFinder; +import org.geotools.feature.NameImpl; import org.geotools.filter.FunctionExpression; import org.geotools.filter.FunctionExpressionImpl; import org.geotools.filter.FunctionFactory; import org.geotools.filter.FunctionImpl; import org.geotools.util.logging.Logging; +import org.opengis.feature.type.Name; import org.opengis.filter.FilterFactory; import org.opengis.filter.capability.FunctionName; import org.opengis.filter.expression.Expression; @@ -53,7 +55,7 @@ public class DefaultFunctionFactory implements FunctionFactory { private static final Logger LOGGER = Logging.getLogger("org.geotools.filter"); private FilterFactory filterFactory = CommonFactoryFinder.getFilterFactory(null); - private Map functionCache; + private Map functionCache; public List getFunctionNames() { ArrayList list = new ArrayList(functionCache().size()); @@ -65,11 +67,15 @@ public class DefaultFunctionFactory implements FunctionFactory { } return list; } - + public Function function(String name, List parameters, Literal fallback) { + return function(new NameImpl(name), parameters, fallback); + } + + public Function function(Name name, List parameters, Literal fallback) { // cache lookup - String key = functionName(name); + Name key = functionName(name); FunctionDescriptor fd = functionCache().get(key); if (fd == null) { fd = functionCache().get(name); @@ -91,7 +97,7 @@ public class DefaultFunctionFactory implements FunctionFactory { return null; } - private Map functionCache() { + private Map functionCache() { if (functionCache == null) { synchronized(this) { if (functionCache == null) { @@ -126,20 +132,21 @@ public class DefaultFunctionFactory implements FunctionFactory { } return functionName; } - private Map loadFunctions() { - Map functionMap = new HashMap(); + private Map loadFunctions() { + Map functionMap = new HashMap(); Set functions = CommonFactoryFinder.getFunctions(null); for (Iterator i = functions.iterator(); i.hasNext();) { Function function = (Function) i.next(); FunctionName functionName = getFunctionName( function ); - String name = function.getName(); + Name name = functionName.getFunctionName(); + FunctionDescriptor fd = new FunctionDescriptor( functionName, function.getClass() ); // if("rint".equals(functionName.getName())){ // System.out.println("Loaded rint"); // } // needed to insert justin's name hack here to ensure consistent lookup - String key = functionName(name); + Name key = functionName(name); if( functionMap.containsKey(key)){ // conflicted name - probably a cut and paste error when creating functionName FunctionDescriptor conflict = functionMap.get(key); @@ -150,7 +157,8 @@ public class DefaultFunctionFactory implements FunctionFactory { return functionMap; } - private String functionName(String name) { + private Name functionName(Name functionName) { + String name = functionName.getLocalPart(); //strip off "Function" prefix int index = -1; @@ -168,7 +176,7 @@ public class DefaultFunctionFactory implements FunctionFactory { //char c = name.charAt(0); //name = name.replaceFirst("" + c, "" + Character.toUpperCase(c)); - return name; + return new NameImpl(functionName.getNamespaceURI(), functionName.getSeparator(), name); } static class FunctionDescriptor { diff --git a/modules/library/main/src/main/java/org/geotools/filter/function/FilterFunction_bufferWithSegments.java b/modules/library/main/src/main/java/org/geotools/filter/function/FilterFunction_bufferWithSegments.java index 7c81632..18ee483 100644 --- a/modules/library/main/src/main/java/org/geotools/filter/function/FilterFunction_bufferWithSegments.java +++ b/modules/library/main/src/main/java/org/geotools/filter/function/FilterFunction_bufferWithSegments.java @@ -33,7 +33,7 @@ import com.vividsolutions.jts.geom.Geometry; */ public class FilterFunction_bufferWithSegments extends FunctionExpressionImpl { - public static FunctionName NAME = new FunctionNameImpl("buffer", + public static FunctionName NAME = new FunctionNameImpl("bufferWithSegments", parameter("buffer", Geometry.class), parameter("geometry", Geometry.class), parameter("distance", Number.class), diff --git a/modules/library/main/src/test/java/org/geotools/filter/function/FunctionFactoryTest.java b/modules/library/main/src/test/java/org/geotools/filter/function/FunctionFactoryTest.java index 4460ea3..f61d036 100644 --- a/modules/library/main/src/test/java/org/geotools/filter/function/FunctionFactoryTest.java +++ b/modules/library/main/src/test/java/org/geotools/filter/function/FunctionFactoryTest.java @@ -31,12 +31,14 @@ import java.util.concurrent.Future; import org.geotools.factory.CommonFactoryFinder; import org.geotools.factory.FactoryIteratorProvider; import org.geotools.factory.GeoTools; +import org.geotools.feature.NameImpl; import org.geotools.filter.FunctionFactory; import org.geotools.filter.FunctionImpl; import org.geotools.filter.capability.FunctionNameImpl; import org.junit.AfterClass; import org.junit.BeforeClass; import org.junit.Test; +import org.opengis.feature.type.Name; import org.opengis.filter.FilterFactory; import org.opengis.filter.capability.FunctionName; import org.opengis.filter.expression.Expression; @@ -69,7 +71,10 @@ public class FunctionFactoryTest { } public Function function(String name, List args, Literal fallback) { - if ("foo".equals(name)) { + return function(new NameImpl(name), args, fallback); + } + public Function function(Name name, List args, Literal fallback) { + if ("foo".equals(name.getLocalPart())) { return new FunctionImpl() { @Override public Object evaluate(Object object, Class context) { diff --git a/modules/library/opengis/src/main/java/org/opengis/filter/capability/FunctionName.java b/modules/library/opengis/src/main/java/org/opengis/filter/capability/FunctionName.java index 03ba026..fbed932 100644 --- a/modules/library/opengis/src/main/java/org/opengis/filter/capability/FunctionName.java +++ b/modules/library/opengis/src/main/java/org/opengis/filter/capability/FunctionName.java @@ -23,6 +23,7 @@ package org.opengis.filter.capability; import java.util.List; import org.opengis.annotation.UML; +import org.opengis.feature.type.Name; import org.opengis.parameter.Parameter; import static org.opengis.annotation.Specification.*; @@ -51,6 +52,15 @@ import static org.opengis.annotation.Specification.*; * @source $URL$ */ public interface FunctionName extends Operator { + + /** + * The qualified name of the function. + *

+ * Client code should this method over {@link Operator#getName()} to handle qualified names. + *

+ */ + Name getFunctionName(); + /** * Number of arguments the function accepts. *

diff --git a/modules/library/opengis/src/main/java/org/opengis/filter/capability/Operator.java b/modules/library/opengis/src/main/java/org/opengis/filter/capability/Operator.java index 393de0c..726cc0a 100644 --- a/modules/library/opengis/src/main/java/org/opengis/filter/capability/Operator.java +++ b/modules/library/opengis/src/main/java/org/opengis/filter/capability/Operator.java @@ -23,6 +23,7 @@ package org.opengis.filter.capability; import static org.opengis.annotation.Specification.UNSPECIFIED; import org.opengis.annotation.UML; +import org.opengis.feature.type.Name; /** * Indicates a supported Operator. @@ -54,7 +55,7 @@ public interface Operator { */ @UML(identifier="name", specification=UNSPECIFIED) String getName(); - + /** * The supported interface enabled by this Operator. *

diff --git a/modules/unsupported/process/src/main/java/org/geotools/process/function/ProcessFunctionFactory.java b/modules/unsupported/process/src/main/java/org/geotools/process/function/ProcessFunctionFactory.java index 0f657eb..718b505 100644 --- a/modules/unsupported/process/src/main/java/org/geotools/process/function/ProcessFunctionFactory.java +++ b/modules/unsupported/process/src/main/java/org/geotools/process/function/ProcessFunctionFactory.java @@ -24,6 +24,7 @@ import java.util.List; import java.util.Map; import org.geotools.data.Parameter; +import org.geotools.feature.NameImpl; import org.geotools.filter.FunctionFactory; import org.geotools.filter.capability.FunctionNameImpl; import org.geotools.process.ProcessFactory; @@ -78,25 +79,29 @@ public class ProcessFunctionFactory implements FunctionFactory { /** * Maps from function to process name */ - HashMap functionToProcess; - + HashMap processToFunction; + /** * The cache list of functions wrapping processes */ private ArrayList functionNames; public Function function(String name, List args, Literal fallback) { + return function(new NameImpl(name), args, fallback); + } + + public Function function(Name processName, List args, Literal fallback) { // if the param function just return it - if(name.equals(ParameterFunction.NAME)) { + if(processName.equals(new NameImpl(ParameterFunction.NAME))) { return new ParameterFunction(fallback, args); } // lookup the process - if(functionToProcess == null) { + if(functionNames == null) { init(); } - Name processName = functionToProcess.get(name); - if(processName == null) { + + if (!processToFunction.containsKey(processName)) { // no such function return null; } else { @@ -104,9 +109,11 @@ public class ProcessFunctionFactory implements FunctionFactory { org.geotools.process.Process process = Processors.createProcess(processName); Map> parameters = Processors.getParameterInfo(processName); if (process instanceof RenderingProcess){ - return new RenderingProcessFunction(name, processName, args, parameters, (RenderingProcess) process, fallback); + return new RenderingProcessFunction(processName.getLocalPart(), processName, args, + parameters, (RenderingProcess) process, fallback); } else { - return new ProcessFunction(name, processName, args, parameters, process, fallback); + return new ProcessFunction(processName.getLocalPart(), processName, args, parameters, + process, fallback); } } } @@ -120,26 +127,27 @@ public class ProcessFunctionFactory implements FunctionFactory { } private synchronized void init() { - if(functionNames == null || functionToProcess == null) { + if(functionNames == null) { // collect and sort the factories to have a reproducable list of function names List factories = new ArrayList(Processors .getProcessFactories()); Collections.sort(factories, FACTORY_COMPARATOR); // collect name and params of all processes resulting in a single output - functionToProcess = new HashMap(); + processToFunction = new HashMap(); functionNames = new ArrayList(); for (ProcessFactory factory : factories) { for (Name processName : factory.getNames()) { - String functionName = processName.getURI(); Map> resultInfo = factory.getResultInfo(processName, null); // check there is a single output if(getPrimary(resultInfo) != null) { Map> parameterInfo = factory.getParameterInfo(processName); List argumentNames = new ArrayList(parameterInfo.keySet()); - functionNames.add(new FunctionNameImpl(functionName, argumentNames)); - functionToProcess.put(functionName, processName); + + FunctionName functionName = new FunctionNameImpl(processName, argumentNames); + functionNames.add(functionName); + processToFunction.put(processName, functionName); } } } @@ -167,7 +175,7 @@ public class ProcessFunctionFactory implements FunctionFactory { */ public void clear() { functionNames = null; - functionToProcess = null; + processToFunction = null; } }