001: /*
002: * GeoTools - OpenSource mapping toolkit
003: * http://geotools.org
004: * (C) 2002-2006, GeoTools Project Managment Committee (PMC)
005: *
006: * This library is free software; you can redistribute it and/or
007: * modify it under the terms of the GNU Lesser General Public
008: * License as published by the Free Software Foundation;
009: * version 2.1 of the License.
010: *
011: * This library is distributed in the hope that it will be useful,
012: * but WITHOUT ANY WARRANTY; without even the implied warranty of
013: * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
014: * Lesser General Public License for more details.
015: */
016: package org.geotools.filter.visitor;
017:
018: import java.util.Iterator;
019: import java.util.logging.Logger;
020:
021: import org.geotools.filter.AttributeExpression;
022: import org.geotools.filter.BetweenFilter;
023: import org.geotools.filter.CompareFilter;
024: import org.geotools.filter.Expression;
025: import org.geotools.filter.FidFilter;
026: import org.geotools.filter.Filter;
027: import org.geotools.filter.Filters;
028: import org.geotools.filter.FunctionExpression;
029: import org.geotools.filter.GeometryFilter;
030: import org.geotools.filter.LikeFilter;
031: import org.geotools.filter.LiteralExpression;
032: import org.geotools.filter.LogicFilter;
033: import org.geotools.filter.MathExpression;
034: import org.geotools.filter.NullFilter;
035: import org.opengis.filter.And;
036: import org.opengis.filter.BinaryComparisonOperator;
037: import org.opengis.filter.BinaryLogicOperator;
038: import org.opengis.filter.ExcludeFilter;
039: import org.opengis.filter.FilterVisitor;
040: import org.opengis.filter.Id;
041: import org.opengis.filter.IncludeFilter;
042: import org.opengis.filter.Not;
043: import org.opengis.filter.Or;
044: import org.opengis.filter.PropertyIsBetween;
045: import org.opengis.filter.PropertyIsEqualTo;
046: import org.opengis.filter.PropertyIsGreaterThan;
047: import org.opengis.filter.PropertyIsGreaterThanOrEqualTo;
048: import org.opengis.filter.PropertyIsLessThan;
049: import org.opengis.filter.PropertyIsLessThanOrEqualTo;
050: import org.opengis.filter.PropertyIsLike;
051: import org.opengis.filter.PropertyIsNotEqualTo;
052: import org.opengis.filter.PropertyIsNull;
053: import org.opengis.filter.expression.ExpressionVisitor;
054: import org.opengis.filter.spatial.BBOX;
055: import org.opengis.filter.spatial.Beyond;
056: import org.opengis.filter.spatial.BinarySpatialOperator;
057: import org.opengis.filter.spatial.Contains;
058: import org.opengis.filter.spatial.Crosses;
059: import org.opengis.filter.spatial.DWithin;
060: import org.opengis.filter.spatial.Disjoint;
061: import org.opengis.filter.spatial.Equals;
062: import org.opengis.filter.spatial.Intersects;
063: import org.opengis.filter.spatial.Overlaps;
064: import org.opengis.filter.spatial.Touches;
065: import org.opengis.filter.spatial.Within;
066:
067: /**
068: * A basic implementation of the FilterVisitor interface.
069: * <p>
070: * This class implements the full FilterVisitor interface and will visit every
071: * member of a Filter object. This class performs no actions and is not intended
072: * to be used directly, instead extend it and overide the methods for the
073: * expression types you are interested in. Remember to call the super method
074: * if you want to ensure that the entier filter tree is still visited.
075: * </p>
076: * <p>
077: * You may still need to implement FilterVisitor directly if the visit order
078: * set out in this class does not meet your needs. This class visits in sequence
079: * i.e. Left - Middle - Right for all expressions which have sub-expressions.
080: * </p>
081: * @deprecated Please use DefaultFilterVisitor (to stick with only opengis Filter)
082: * @author James Macgill, Penn State
083: * @author Justin Deoliveira, The Open Planning Project
084: * @source $URL: http://svn.geotools.org/geotools/tags/2.4.1/modules/library/main/src/main/java/org/geotools/filter/visitor/AbstractFilterVisitor.java $
085: */
086: public class AbstractFilterVisitor implements
087: org.geotools.filter.FilterVisitor, FilterVisitor {
088:
089: /** Standard java logger */
090: private static Logger LOGGER = org.geotools.util.logging.Logging
091: .getLogger("org.geotools.filter.visitor");
092:
093: /** expression visitor */
094: private ExpressionVisitor expressionVisitor;
095:
096: /**
097: * Empty constructor
098: */
099: public AbstractFilterVisitor() {
100: this (new NullExpressionVisitor());
101: }
102:
103: /**
104: * Constructs the filter visitor with an expression visitor.
105: * <p>
106: * Using this constructor allows expressions of a filter to be visited as well.
107: * </p>
108: * @param expressionVisitor
109: */
110: public AbstractFilterVisitor(ExpressionVisitor expressionVisitor) {
111: this .expressionVisitor = expressionVisitor;
112: }
113:
114: /**
115: * Does nothing; will return provided data unmodified.
116: */
117: public Object visit(IncludeFilter filter, Object data) {
118: return data;
119: }
120:
121: /**
122: * Does nothing; will return provided data unmodified.
123: */
124: public Object visit(ExcludeFilter filter, Object data) {
125: return data;
126: }
127:
128: /**
129: * Does nothing.
130: */
131: public Object visitNullFilter(Object data) {
132: return null;
133: }
134:
135: /**
136: * @see org.geotools.filter.FilterVisitor#visit(org.geotools.filter.Filter)
137: * @deprecated
138: */
139: public void visit(Filter filter) {
140: // James - unknown filter type (not good, should not happen)
141: }
142:
143: /**
144: * @see org.geotools.filter.FilterVisitor#visit(org.geotools.filter.BetweenFilter)
145: * @deprecated use {@link #visit(PropertyIsBetween, Object)}
146: */
147: public void visit(BetweenFilter filter) {
148: if (filter.getLeftValue() != null) {
149: filter.getLeftValue().accept(this );
150: }
151:
152: if (filter.getMiddleValue() != null) {
153: filter.getMiddleValue().accept(this );
154: }
155:
156: if (filter.getRightValue() != null) {
157: filter.getRightValue().accept(this );
158: }
159: }
160:
161: /**
162: * Visits filter.getLowerBoundary(),filter.getExpression(),filter.getUpperBoundary() if an
163: * expression visitor was set.
164: */
165: public Object visit(PropertyIsBetween filter, Object data) {
166: if (filter.getLowerBoundary() != null) {
167: filter.getLowerBoundary().accept(expressionVisitor, data);
168: }
169: if (filter.getExpression() != null) {
170: filter.getExpression().accept(expressionVisitor, data);
171: }
172: if (filter.getUpperBoundary() != null) {
173: filter.getUpperBoundary().accept(expressionVisitor, data);
174: }
175: return filter;
176: }
177:
178: /**
179: * @see org.geotools.filter.FilterVisitor#visit(org.geotools.filter.CompareFilter)
180: * @deprecated use one of {@link #visit(PropertyIsEqualTo, Object)},
181: * {@link #visit(PropertyIsNotEqualTo, Object)}, {@link #visit(PropertyIsLessThan, Object)},
182: * {@link #visit(PropertyIsLessThanOrEqualTo, Object)},{@link #visit(PropertyIsGreaterThan, Object)},
183: * {@link #visit(PropertyIsGreaterThanEqualTo, Object)}
184: */
185: public void visit(CompareFilter filter) {
186: if (filter.getLeftValue() != null) {
187: filter.getLeftValue().accept(this );
188: }
189:
190: if (filter.getRightValue() != null) {
191: filter.getRightValue().accept(this );
192: }
193: }
194:
195: /**
196: * Visits filter.getExpression1(), and filter.getExpression2() if an expression visitor
197: * was set.
198: */
199: protected Object visit(BinaryComparisonOperator filter, Object data) {
200: if (expressionVisitor != null) {
201: if (filter.getExpression1() != null) {
202: filter.getExpression1().accept(expressionVisitor, data);
203: }
204: if (filter.getExpression2() != null) {
205: filter.getExpression2().accept(expressionVisitor, data);
206: }
207: }
208:
209: return filter;
210: }
211:
212: /**
213: * Visits filter.getExpression1(), and filter.getExpression2() if an expression visitor
214: * was set.
215: */
216: public Object visit(PropertyIsEqualTo filter, Object data) {
217: return visit((BinaryComparisonOperator) filter, data);
218: }
219:
220: /**
221: * Visits filter.getExpression1(), and filter.getExpression2() if an expression visitor
222: * was set.
223: */
224: public Object visit(PropertyIsNotEqualTo filter, Object data) {
225: return visit((BinaryComparisonOperator) filter, data);
226: }
227:
228: /**
229: * Visits filter.getExpression1(), and filter.getExpression2() if an expression visitor
230: * was set.
231: */
232: public Object visit(PropertyIsLessThan filter, Object data) {
233: return visit((BinaryComparisonOperator) filter, data);
234: }
235:
236: /**
237: * Visits filter.getExpression1(), and filter.getExpression2() if an expression visitor
238: * was set.
239: */
240: public Object visit(PropertyIsLessThanOrEqualTo filter, Object data) {
241: return visit((BinaryComparisonOperator) filter, data);
242: }
243:
244: /**
245: * Visits filter.getExpression1(), and filter.getExpression2() if an expression visitor
246: * was set.
247: */
248: public Object visit(PropertyIsGreaterThan filter, Object data) {
249: return visit((BinaryComparisonOperator) filter, data);
250: }
251:
252: /**
253: * Visits filter.getExpression1(), and filter.getExpression2() if an expression visitor
254: * was set.
255: */
256: public Object visit(PropertyIsGreaterThanOrEqualTo filter,
257: Object data) {
258: return visit((BinaryComparisonOperator) filter, data);
259: }
260:
261: /**
262: * @see org.geotools.filter.FilterVisitor#visit(org.geotools.filter.GeometryFilter)
263: */
264: public void visit(GeometryFilter filter) {
265: if (filter.getLeftGeometry() != null) {
266: filter.getLeftGeometry().accept(this );
267: }
268:
269: if (filter.getRightGeometry() != null) {
270: filter.getRightGeometry().accept(this );
271: }
272: }
273:
274: /**
275: * does nothing
276: */
277: public Object visit(BBOX filter, Object data) {
278: return filter;
279: }
280:
281: /**
282: * Visits filter.getExpression1(),filter.getExpression2() if an expression visitor has been
283: * set.
284: */
285: protected Object visit(BinarySpatialOperator filter, Object data) {
286: if (expressionVisitor != null) {
287: if (filter.getExpression1() != null) {
288: filter.getExpression1().accept(expressionVisitor, data);
289: }
290: if (filter.getExpression2() != null) {
291: filter.getExpression2().accept(expressionVisitor, data);
292: }
293: }
294:
295: return filter;
296: }
297:
298: /**
299: * Visits filter.getExpression1(),filter.getExpression2() if an expression visitor has been
300: * set.
301: */
302: public Object visit(Beyond filter, Object data) {
303: return visit((BinarySpatialOperator) filter, data);
304: }
305:
306: /**
307: * Visits filter.getExpression1(),filter.getExpression2() if an expression visitor has been
308: * set.
309: */
310: public Object visit(Contains filter, Object data) {
311: return visit((BinarySpatialOperator) filter, data);
312: }
313:
314: /**
315: * Visits filter.getExpression1(),filter.getExpression2() if an expression visitor has been
316: * set.
317: */
318: public Object visit(Crosses filter, Object data) {
319: return visit((BinarySpatialOperator) filter, data);
320: }
321:
322: /**
323: * Visits filter.getExpression1(),filter.getExpression2() if an expression visitor has been
324: * set.
325: */
326: public Object visit(Disjoint filter, Object data) {
327: return visit((BinarySpatialOperator) filter, data);
328: }
329:
330: /**
331: * Visits filter.getExpression1(),filter.getExpression2() if an expression visitor has been
332: * set.
333: */
334: public Object visit(DWithin filter, Object data) {
335: return visit((BinarySpatialOperator) filter, data);
336: }
337:
338: /**
339: * Visits filter.getExpression1(),filter.getExpression2() if an expression visitor has been
340: * set.
341: */
342: public Object visit(Equals filter, Object data) {
343: return visit((BinarySpatialOperator) filter, data);
344: }
345:
346: /**
347: * Visits filter.getExpression1(),filter.getExpression2() if an expression visitor has been
348: * set.
349: */
350: public Object visit(Intersects filter, Object data) {
351: return visit((BinarySpatialOperator) filter, data);
352: }
353:
354: /**
355: * Visits filter.getExpression1(),filter.getExpression2() if an expression visitor has been
356: * set.
357: */
358: public Object visit(Overlaps filter, Object data) {
359: return visit((BinarySpatialOperator) filter, data);
360: }
361:
362: /**
363: * Visits filter.getExpression1(),filter.getExpression2() if an expression visitor has been
364: * set.
365: */
366: public Object visit(Touches filter, Object data) {
367: return visit((BinarySpatialOperator) filter, data);
368: }
369:
370: /**
371: * Visits filter.getExpression1(),filter.getExpression2() if an expression visitor has been
372: * set.
373: */
374: public Object visit(Within filter, Object data) {
375: return visit((BinarySpatialOperator) filter, data);
376: }
377:
378: /**
379: * @see org.geotools.filter.FilterVisitor#visit(org.geotools.filter.LikeFilter)
380: * @deprecated use {@link #visit(PropertyIsLike, Object)}
381: */
382: public void visit(LikeFilter filter) {
383: if (filter.getValue() != null) {
384: filter.getValue().accept(this );
385: }
386: }
387:
388: /**
389: * Visits filter.getExpression() if an expression visitor was set.
390: */
391: public Object visit(PropertyIsLike filter, Object data) {
392: if (expressionVisitor != null) {
393: if (filter.getExpression() != null) {
394: filter.getExpression().accept(expressionVisitor, null);
395: }
396: }
397:
398: return filter;
399: }
400:
401: /**
402: * @see org.geotools.filter.FilterVisitor#visit(org.geotools.filter.LogicFilter)
403: * @deprecated use one of {@link #visit(And, Object)},{@link #visit(Or, Object)},
404: * {@link #visit(Not, Object)}
405: */
406: public void visit(LogicFilter filter) {
407: for (Iterator it = filter.getFilterIterator(); it.hasNext();) {
408: Filters.accept((org.opengis.filter.Filter) it.next(), this );
409: }
410: }
411:
412: /**
413: * Visits elements of filter.getChildren().
414: */
415: protected Object visit(BinaryLogicOperator filter, Object data) {
416: if (filter.getChildren() != null) {
417: for (Iterator i = filter.getChildren().iterator(); i
418: .hasNext();) {
419: org.opengis.filter.Filter child = (org.opengis.filter.Filter) i
420: .next();
421: child.accept(this , data);
422: }
423: }
424:
425: return filter;
426: }
427:
428: /**
429: * Visits elements of filter.getChildren().
430: */
431: public Object visit(And filter, Object data) {
432: return visit((BinaryLogicOperator) filter, data);
433: }
434:
435: /**
436: * Visits elements of filter.getChildren().
437: */
438: public Object visit(Or filter, Object data) {
439: return visit((BinaryLogicOperator) filter, data);
440: }
441:
442: /**
443: * Visits filter.getFilter().
444: */
445: public Object visit(Not filter, Object data) {
446: if (filter.getFilter() != null) {
447: filter.getFilter().accept(this , data);
448: }
449:
450: return filter;
451: }
452:
453: /**
454: * @see org.geotools.filter.FilterVisitor#visit(org.geotools.filter.NullFilter)
455: * @deprecated use {@link #visit(PropertyIsNull, Object)}
456: */
457: public void visit(NullFilter filter) {
458: if (filter.getNullCheckValue() != null) {
459: filter.getNullCheckValue().accept(this );
460: }
461: }
462:
463: /**
464: * Visits filter.getExpression() if an expression visitor was set.
465: */
466: public Object visit(PropertyIsNull filter, Object data) {
467: if (expressionVisitor != null) {
468: if (filter.getExpression() != null) {
469: filter.getExpression().accept(expressionVisitor, data);
470: }
471: }
472: return filter;
473: }
474:
475: /**
476: * @see org.geotools.filter.FilterVisitor#visit(org.geotools.filter.FidFilter)
477: * @deprecated use {@link #visit(Id, Object)}
478: */
479: public void visit(FidFilter filter) {
480: // nothing to do, the feature id is implicit and should always be
481: // included, but cannot be derived from the filter itself
482: }
483:
484: /**
485: * Does nothing.
486: */
487: public Object visit(Id filter, Object data) {
488: //do nothing
489: return filter;
490: }
491:
492: /**
493: * @see org.geotools.filter.FilterVisitor#visit(org.geotools.filter.AttributeExpression)
494: */
495: public void visit(AttributeExpression expression) {
496: //nothing to do
497: }
498:
499: /**
500: * @see org.geotools.filter.FilterVisitor#visit(org.geotools.filter.Expression)
501: */
502: public void visit(Expression expression) {
503: // nothing to do
504: }
505:
506: /**
507: * @see org.geotools.filter.FilterVisitor#visit(org.geotools.filter.LiteralExpression)
508: */
509: public void visit(LiteralExpression expression) {
510: // nothing to do
511: }
512:
513: /**
514: * @see org.geotools.filter.FilterVisitor#visit(org.geotools.filter.MathExpression)
515: */
516: public void visit(MathExpression expression) {
517: if (expression.getLeftValue() != null) {
518: expression.getLeftValue().accept(this );
519: }
520:
521: if (expression.getRightValue() != null) {
522: expression.getRightValue().accept(this );
523: }
524: }
525:
526: /**
527: * @see org.geotools.filter.FilterVisitor#visit(org.geotools.filter.FunctionExpression)
528: */
529: public void visit(FunctionExpression expression) {
530: Expression[] args = expression.getArgs();
531:
532: for (int i = 0; i < args.length; i++) {
533: if (args[i] != null) {
534: args[i].accept(this);
535: }
536: }
537: }
538: }
|