## org.opengis.filter
Interface FilterFactory

All Known Subinterfaces:
  FilterFactory2

    public interface FilterFactory

Interface whose methods allow the caller to create instances of the various `Filter` and `Expression` subclasses.

Since:
  GeoAPI 2.0
Version:
  Implementation specification 1.0

Method Summary
`Add` `add(Expression expr1, Expression expr2)` Computes the numeric addition of the first and second operand.
`And` `and(Filter f, Filter g)` `AND` filter between two filters.
`And` `and(List<Filter> f)` `AND` filter between a list of filters.
`ArithmeticOperators` `arithmeticOperators(boolean simple, Functions functions)` arithmetic operators
`BBOX` `bbox(String propertyName, double minx, double miny, double maxx, double maxy, String srs)` Checks if the bounding box of the feature's geometry overlaps the indicated bounds.
`PropertyIsBetween` `between(Expression expr, Expression lower, Expression upper)` A compact way of encoding a range check.
`Beyond` `beyond(String propertyName, Geometry geometry, double distance, String units)` Check if all of a feature's geometry is more distant than the given distance from this object's geometry.
`FilterCapabilities` `capabilities(String version, ScalarCapabilities scalar, SpatialCapabilities spatial, IdCapabilities id)` filter capabilities
`ComparisonOperators` `comparisonOperators(Operator[] comparisonOperators)` comparison operators
`Contains` `contains(String propertyName, Geometry geometry)` Checks if the the first geometric operand contains the second.
`Crosses` `crosses(String propertyName, Geometry geometry)` Checks if the first geometric operand crosses the second.
`Disjoint` `disjoint(String propertyName, Geometry geometry)` Checks if the first operand is disjoint from the second.
`Divide` `divide(Expression expr1, Expression expr2)` Computes the numeric quotient resulting from dividing the first operand by the second.
`DWithin` `dwithin(String propertyName, Geometry geometry, double distance, String units)` Checks if any part of the first geometry lies within the given distance of the second geometry.
`PropertyIsEqualTo` `equal(Expression expr1, Expression expr2, boolean matchCase)` Compares that two sub-expressions are equal to eacher other
`PropertyIsEqualTo` `equals(Expression expr1, Expression expr2)` Compares that two sub-expressions are equal to each other.
`Equals` `equals(String propertyName, Geometry geometry)` Checks if the geometry of the two operands are equal.
`FeatureId` `featureId(String id)` Creates a new feautre id from a string
`Function` `function(String name, Expression arg1)` Call into some implementation-specific function with one argument.
`Function` `function(String name, Expression[] args)` Call into some implementation-specific function.
`Function` `function(String name, Expression arg1, Expression arg2)` Call into some implementation-specific function with two arguments.
`Function` `function(String name, Expression arg1, Expression arg2, Expression arg3)` Call into some implementation-specific function with three arguments.
`FunctionName` `functionName(String name, int nargs)` function name
`Functions` `functions(FunctionName[] functionNames)` functions
`GmlObjectId` `gmlObjectId(String id)` Creates a new gml object id from a string
`PropertyIsGreaterThan` `greater(Expression expr1, Expression expr2)` Checks that the first sub-expression is greater than the second subexpression.
`PropertyIsGreaterThanOrEqualTo` `greaterOrEqual(Expression expr1, Expression expr2)` Checks that the first sub-expression is greater or equal to the second subexpression.
`Id` `id(Set<? extends Identifier> ids)` Passes only for objects that have one of the IDs given to this object.
`IdCapabilities` `idCapabilities(boolean eid, boolean fid)` id capabilities
`Intersects` `intersects(String propertyName, Geometry geometry)` Checks if the two geometric operands intersect.
`PropertyIsNull` `isNull(Expression expr)` Checks if an expression's value is `null`.
`PropertyIsLessThan` `less(Expression expr1, Expression expr2)` Checks that its first sub-expression is less than its second subexpression.
`PropertyIsLessThanOrEqualTo` `lessOrEqual(Expression expr1, Expression expr2)` Checks that its first sub-expression is less than or equal to its second subexpression.
`PropertyIsLike` `like(Expression expr, String pattern)` Character string comparison operator with pattern matching and default wildcards.
`PropertyIsLike` `like(Expression expr, String pattern, String wildcard, String singleChar, String escape)` Character string comparison operator with pattern matching and specified wildcards.
`Literal` `literal(boolean b)` A constant, literal `Boolean` value that can be used in expressions.
`Literal` `literal(byte b)` A constant, literal `Byte` value that can be used in expressions.
`Literal` `literal(char c)` A constant, literal `Character` value that can be used in expressions.
`Literal` `literal(double d)` A constant, literal `Double` value that can be used in expressions.
`Literal` `literal(float f)` A constant, literal `Float` value that can be used in expressions.
`Literal` `literal(int i)` A constant, literal `Integer` value that can be used in expressions.
`Literal` `literal(long l)` A constant, literal `Long` value that can be used in expressions.
`Literal` `literal(Object obj)` A constant, literal value that can be used in expressions.
`Literal` `literal(short s)` A constant, literal `Short` value that can be used in expressions.
`Multiply` `multiply(Expression expr1, Expression expr2)` Computes the numeric product of their first and second operand.
`Not` `not(Filter f)` Reverses the logical value of a filter.
`PropertyIsNotEqualTo` `notEqual(Expression expr1, Expression expr2, boolean matchCase)` Checks that the first sub-expression is not equal to the second subexpression.
`Operator` `operator(String name)` operators
`Or` `or(Filter f, Filter g)` `OR` filter between two filters.
`Or` `or(List<Filter> f)` `OR` filter between a list of filters.
`Overlaps` `overlaps(String propertyName, Geometry geometry)` Checks if the interior of the first geometry somewhere overlaps the interior of the second geometry.
`PropertyName` `property(String name)` Retrieves the value of a feature's property.
`ScalarCapabilities` `scalarCapabilities(ComparisonOperators comparison, ArithmeticOperators arithmetic, boolean logical)` scalar capabilities
`SortBy` `sort(String propertyName, SortOrder order)` Indicates an property by which contents should be sorted, along with intended order.
`SpatialCapabilities` `spatialCapabilities(GeometryOperand[] geometryOperands, SpatialOperators spatial)` spatial capabilities
`SpatialOperator` `spatialOperator(String name, GeometryOperand[] geometryOperands)` spatial operator
`SpatialOperators` `spatialOperators(SpatialOperator[] spatialOperators)` spatial operators
`Subtract` `subtract(Expression expr1, Expression expr2)` Computes the numeric difference between the first and second operand.
`Touches` `touches(String propertyName, Geometry geometry)` Checks if the feature's geometry touches, but does not overlap with the geometry held by this object.
`Within` `within(String propertyName, Geometry geometry)` Checks if the feature's geometry is completely contained by the specified constant geometry.

Method Detail

### featureId

    FeatureId featureId(String id)

  Creates a new feautre id from a string

### gmlObjectId

    GmlObjectId gmlObjectId(String id)

  Creates a new gml object id from a string

### and

    And and(Filter f,
            Filter g)

  `AND` filter between two filters.

### and

    And and(List<Filter> f)

  `AND` filter between a list of filters.

### or

    Or or(Filter f,
          Filter g)

  `OR` filter between two filters.

### or

    Or or(List<Filter> f)

  `OR` filter between a list of filters.

### not

    Not not(Filter f)

  Reverses the logical value of a filter.

### id

    Id id(Set<? extends Identifier> ids)

  Passes only for objects that have one of the IDs given to this object.

### property

    PropertyName property(String name)

  Retrieves the value of a feature's property.

### between

    PropertyIsBetween between(Expression expr,
                              Expression lower,
                              Expression upper)

  A compact way of encoding a range check.

### equals

    PropertyIsEqualTo equals(Expression expr1,
                             Expression expr2)

  Compares that two sub-expressions are equal to each other.

  TODO:
    should be equal (so equals can refer to geometry)

### equal

    PropertyIsEqualTo equal(Expression expr1,
                            Expression expr2,
                            boolean matchCase)

  Compares that two sub-expressions are equal to eacher other

### notEqual

    PropertyIsNotEqualTo notEqual(Expression expr1,
                                  Expression expr2,
                                  boolean matchCase)

  Checks that the first sub-expression is not equal to the second subexpression.

### greater

    PropertyIsGreaterThan greater(Expression expr1,
                                  Expression expr2)

  Checks that the first sub-expression is greater than the second subexpression.

### greaterOrEqual

    PropertyIsGreaterThanOrEqualTo greaterOrEqual(Expression expr1,
                                                  Expression expr2)

  Checks that the first sub-expression is greater or equal to the second subexpression.

### less

    PropertyIsLessThan less(Expression expr1,
                            Expression expr2)

  Checks that its first sub-expression is less than its second subexpression.

### lessOrEqual

    PropertyIsLessThanOrEqualTo lessOrEqual(Expression expr1,
                                            Expression expr2)

  Checks that its first sub-expression is less than or equal to its second subexpression.

### like

    PropertyIsLike like(Expression expr,
                        String pattern)

  Character string comparison operator with pattern matching and default wildcards.

### like

    PropertyIsLike like(Expression expr,
                        String pattern,
                        String wildcard,
                        String singleChar,
                        String escape)

  Character string comparison operator with pattern matching and specified wildcards.

### isNull

    PropertyIsNull isNull(Expression expr)

  Checks if an expression's value is `null`.

### bbox

    BBOX bbox(String propertyName,
              double minx,
              double miny,
              double maxx,
              double maxy,
              String srs)

  Checks if the bounding box of the feature's geometry overlaps the indicated bounds.

  This method is defined in strict accordance with the Filter 1.0 specification, you may find the FilterFactory2.bbox(Expression, BoundingBox) to be easier to use.

  Parameters:
    `propertyName` - Name of geometry property (for a PropertyName to access a Feature's Geometry)
    `minx` - Minimum "x" value (for a literal BoundingBox)
    `miny` - Minimum "y" value (for a literal BoundingBox)
    `maxx` - Maximum "x" value (for a literal BoundingBox)
    `maxy` - Maximum "y" value (for a literal BoundingBox)
    `srs` - Indicating the CoordianteReferenceSystem to use for a literal BoundingBox

### beyond

    Beyond beyond(String propertyName,
                  Geometry geometry,
                  double distance,
                  String units)

  Check if all of a feature's geometry is more distant than the given distance from this object's geometry.

### contains

    Contains contains(String propertyName,
                      Geometry geometry)

  Checks if the the first geometric operand contains the second.

### crosses

    Crosses crosses(String propertyName,
                    Geometry geometry)

  Checks if the first geometric operand crosses the second.

### disjoint

    Disjoint disjoint(String propertyName,
                      Geometry geometry)

  Checks if the first operand is disjoint from the second.

### dwithin

    DWithin dwithin(String propertyName,
                    Geometry geometry,
                    double distance,
                    String units)

  Checks if any part of the first geometry lies within the given distance of the second geometry.

### equals

    Equals equals(String propertyName,
                  Geometry geometry)

  Checks if the geometry of the two operands are equal.

### intersects

    Intersects intersects(String propertyName,
                          Geometry geometry)

  Checks if the two geometric operands intersect.

### overlaps

    Overlaps overlaps(String propertyName,
                      Geometry geometry)

  Checks if the interior of the first geometry somewhere overlaps the interior of the second geometry.

### touches

    Touches touches(String propertyName,
                    Geometry geometry)

  Checks if the feature's geometry touches, but does not overlap with the geometry held by this object.

### within

    Within within(String propertyName,
                  Geometry geometry)

  Checks if the feature's geometry is completely contained by the specified constant geometry.

### add

    Add add(Expression expr1,
            Expression expr2)

  Computes the numeric addition of the first and second operand.

### divide

    Divide divide(Expression expr1,
                  Expression expr2)

  Computes the numeric quotient resulting from dividing the first operand by the second.

### multiply

    Multiply multiply(Expression expr1,
                      Expression expr2)

  Computes the numeric product of their first and second operand.

### subtract

    Subtract subtract(Expression expr1,
                      Expression expr2)

  Computes the numeric difference between the first and second operand.

### function

    Function function(String name,
                      Expression[] args)

  Call into some implementation-specific function.

### function

    Function function(String name,
                      Expression arg1)

  Call into some implementation-specific function with one argument.

### function

    Function function(String name,
                      Expression arg1,
                      Expression arg2)

  Call into some implementation-specific function with two arguments.

### function

    Function function(String name,
                      Expression arg1,
                      Expression arg2,
                      Expression arg3)

  Call into some implementation-specific function with three arguments.

### literal

    Literal literal(Object obj)

  A constant, literal value that can be used in expressions.

### literal

    Literal literal(byte b)

  A constant, literal `Byte` value that can be used in expressions.

### literal

    Literal literal(short s)

  A constant, literal `Short` value that can be used in expressions.

### literal

    Literal literal(int i)

  A constant, literal `Integer` value that can be used in expressions.

### literal

    Literal literal(long l)

  A constant, literal `Long` value that can be used in expressions.

### literal

    Literal literal(float f)

  A constant, literal `Float` value that can be used in expressions.

### literal

    Literal literal(double d)

  A constant, literal `Double` value that can be used in expressions.

### literal

    Literal literal(char c)

  A constant, literal `Character` value that can be used in expressions.

### literal

    Literal literal(boolean b)

  A constant, literal `Boolean` value that can be used in expressions.

### sort

    SortBy sort(String propertyName,
                SortOrder order)

  Indicates an property by which contents should be sorted, along with intended order.

### operator

    Operator operator(String name)

  operators

### spatialOperator

    SpatialOperator spatialOperator(String name,
                                    GeometryOperand[] geometryOperands)

  spatial operator

### functionName

    FunctionName functionName(String name,
                              int nargs)

  function name

### functions

    Functions functions(FunctionName[] functionNames)

  functions

### spatialOperators

    SpatialOperators spatialOperators(SpatialOperator[] spatialOperators)

  spatial operators

### comparisonOperators

    ComparisonOperators comparisonOperators(Operator[] comparisonOperators)

  comparison operators

### arithmeticOperators

    ArithmeticOperators arithmeticOperators(boolean simple,
                                            Functions functions)

  arithmetic operators

### scalarCapabilities

    ScalarCapabilities scalarCapabilities(ComparisonOperators comparison,
                                          ArithmeticOperators arithmetic,
                                          boolean logical)

  scalar capabilities

### spatialCapabilities

    SpatialCapabilities spatialCapabilities(GeometryOperand[] geometryOperands,
                                            SpatialOperators spatial)

  spatial capabilities

### idCapabilities

    IdCapabilities idCapabilities(boolean eid,
                                  boolean fid)

  id capabilities

### capabilities

    FilterCapabilities capabilities(String version,
                                    ScalarCapabilities scalar,
                                    SpatialCapabilities spatial,
                                    IdCapabilities id)

  filter capabilities

Copyright © 1994-2008 Open Geospatial Consortium. All Rights Reserved.