/branches/v2_0_0_prep/libraries/libRemoteServices/src/org/gvsig/remoteclient/wfs/filters/AbstractFilter.java - Application: gvSIG desktop - gvSIG

svn-gvsig-desktop / branches / v2_0_0_prep / libraries / libRemoteServices / src / org / gvsig / remoteclient / wfs / filters / AbstractFilter.java @ 34026

History | View | Annotate | Download (8.7 KB)

       /* gvSIG. Sistema de Informaci?n Geogr?fica de la Generalitat Valenciana
+       *
        * Copyright (C) 2004 IVER T.I. and Generalitat Valenciana.
+       *
        * This program is free software; you can redistribute it and/or
        * modify it under the terms of the GNU General Public License
        * as published by the Free Software Foundation; either version 2
        * of the License, or (at your option) any later version.
+       *
        * This program 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 General Public License for more details.
+       *
        * You should have received a copy of the GNU General Public License
        * along with this program; if not, write to the Free Software
        * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307,USA.
+       *
        * For more information, contact:
+       *
        *  Generalitat Valenciana
        *   Conselleria d'Infraestructures i Transport
        *   Av. Blasco Ib??ez, 50
        *   46010 VALENCIA
        *   SPAIN
+       *
        *      +34 963862235
        *   gvsig@gva.es
        *      www.gvsig.gva.es
+       *
        *    or
+       *
        *   IVER T.I. S.A
        *   Salamanca 50
        *   46005 Valencia
        *   Spain
+       *
        *   +34 963163400
        *   dac@iver.es
        */
       package org.gvsig.remoteclient.wfs.filters;
       import java.io.ByteArrayInputStream;
       import java.util.ArrayList;
       import java.util.Iterator;
       import java.util.StringTokenizer;
       import java.util.Vector;
       import org.gvsig.fmap.geom.Geometry;
       import org.gvsig.fmap.geom.primitive.Envelope;
       import org.gvsig.remoteclient.wfs.filters.operations.WFSEnvelopeFilterOperation;
       import org.gvsig.remoteclient.wfs.filters.operations.WFSGeometryFilterOperation;
       import org.gvsig.remoteclient.wfs.filters.operations.WFSSpatialFilterOperation;
       /**
        * All classes that implement a "Query Language" must to inherit of
        * this class
+       *
        * @author Jorge Piera Llodra (piera_jor@gva.es)
        */
       public abstract class AbstractFilter implements Filter {
               private BinaryTree root;
               private String currentClause;
               private ISQLExpressionFormat formatter;
               private ArrayList spatialFilterOperations;
               private ArrayList ids = null;
               public AbstractFilter(ISQLExpressionFormat formatter){
                       root = new BinaryTree();
                       this.formatter = formatter;
                       spatialFilterOperations = new ArrayList();
+              }
               /**
                * It returns the Query like a String
                */
               public abstract String toString(BinaryTree tree, String version);
               /**
                * returns the String that represents the logic
                * operator in this query language
                * @param operator
                * Logic operator
                * @return
                */
               public abstract String getLogicalOperator(int operator);
               /**
                * returns the String that represents the relational
                * operator in this query language
                * @param operator
                * Logic operator
                * @return
                */
               public abstract String getRelationalOperator(int operator);
               /**
                * returns the String that represents the geometric
                * operator in this query language
                * @param operator
                * Logic operator
                * @return
                */
               public abstract String getGeometricOperator(int operator);
               /**
                * returns the String that represents the separator
                * operator in this query language
                * @param separator
                * LSeparator "(" or ")"
                * @return
                */
               public abstract String getSeparator(int separator);
               /**
                * Adds a feature id
                * @param id
                * The feature id
                */
               public void addFeatureById(Object id){
                       if (ids == null){
                               ids = new ArrayList();
+                      }
                       ids.add(id);
+              }
               /**
                * @return the ids
                */
               protected ArrayList getIds() {
                       return ids;
+              }
               public void setQueryByAttribute(String query){
                       if (query != null){
                               ByteArrayInputStream is = new ByteArrayInputStream(query.getBytes());
                               String sql = formatter.format(query);
                               if (sql != null){
                                       ParseExpressions expressions = new ParseExpressions();
                                       ArrayList tokens = expressions.parseExpression(sql);
                                       for (int i=0 ; i<tokens.size() ; i++){
                                               String token = (String)tokens.get(i);
                                               root.addTerm(token);
+                                      }
+                              }
+                      }
+              }
               /**
                * It adds a new property and value using the AND
                * operation
                * @param propertyName
                * @param propertyValue
                */
               public void addAndClause(String propertyName, String propertyValue){
                       root.addTerm(propertyName + " = " + propertyValue,
                                       getLogicalOperator(LOGICAL_OPERATOR_AND));
+              }
               public int getSpatialFiltersCount(){
                       return spatialFilterOperations.size();
+              }
               public WFSSpatialFilterOperation getSpatialFilterAt(int index){
                       if (index < spatialFilterOperations.size()){
                               return (WFSSpatialFilterOperation)spatialFilterOperations.get(index);
+                      }
                       return null;
+              }
               public void clearSpatialFilters(){
                       spatialFilterOperations.clear();
+              }
               public void addSpatialFilter(WFSSpatialFilterOperation spatialOperation){
                       spatialFilterOperations.add(spatialOperation);
+              }
               public void addSpatialFilter(Geometry geometry,String attributeName, String nameSpacePrefix, String nameSpaceLocation, String srs, int operation) {
                       addSpatialFilter(new WFSGeometryFilterOperation(geometry, operation, attributeName, nameSpacePrefix, nameSpaceLocation, srs));
+              }
               public void addSpatialFilter(String version, Envelope envelope, String attributeName, String nameSpacePrefix, String nameSpaceLocation, String srs, int operation) {
                       addSpatialFilter(new WFSEnvelopeFilterOperation(envelope, operation, attributeName, nameSpacePrefix, nameSpaceLocation, srs));
+              }
               public void addClause(String value){
                       if (currentClause == null){
                               currentClause = new String("");
+                      }
                       currentClause = currentClause + value;
+              }
               public String toString(String version){
                       if (currentClause != null){
                               setQueryByAttribute(currentClause);
+                      }
                       return toString(root, version);
+              }
               /**
                * Return true if the token is a operator
                * @param operator
                * @return
                */
               public String getOperator(int operator){
                       if (isLogical(operator)){
                               return getLogicalOperator(operator);
                       }else if(isRelational(operator)){
                               return getRelationalOperator(operator);
                       }else if(isGeometric(operator)){
                               return getGeometricOperator(operator);
+                      }
                       return String.valueOf(operator);
+              }
               public int getRelationalOperator(String operator){
                       if (operator.equals("=")){
                               return RELATIONAL_OPERATOR_IS_EQUALS_TO;
                       }else if(operator.equals("!=")){
                               return RELATIONAL_OPERATOR_IS_NOT_EQUALS_TO;
                       }else if(operator.equals("<>")){ // This is another way to tell not-equal
                               return RELATIONAL_OPERATOR_IS_NOT_EQUALS_TO;
                       }else if(operator.equals(">")){
                               return RELATIONAL_OPERATOR_IS_GREATER_THAN;
                       }else if(operator.equals(">=")){
                               return RELATIONAL_OPERATOR_IS_GREATER_THAN_OR_EQUAL_TO;
                       }else if(operator.equals("<")){
                               return RELATIONAL_OPERATOR_IS_LESS_THAN;
                       }else if(operator.equals("<=")){
                               return RELATIONAL_OPERATOR_IS_LESS_THAN_OR_EQUAL_TO;
                       }else if(operator.toUpperCase().equals("LIKE")){
                               return RELATIONAL_OPERATOR_IS_LIKE;
+                      }
                       return RELATIONAL_OPERATOR_IS_EQUALS_TO;
+              }
               public int getLogicalOperator(String operator){
                       if (operator.toUpperCase().equals("AND")){
                               return LOGICAL_OPERATOR_AND;
                       }else if(operator.toUpperCase().equals("NOT")){
                               return LOGICAL_OPERATOR_NOT;
                       }else if(operator.toUpperCase().equals("OR")){
                               return LOGICAL_OPERATOR_OR;
+                      }
                       return LOGICAL_OPERATOR_AND;
+              }
               /**
                * Return true if is a geometric operator
                * @param type
                * @return
                */
               private boolean isGeometric(int type) {
                       if ((type > 19) && (type < 40)){
                               return true;
+                      }
                       return false;
+              }
               /**
                * Return true if is a relational operator
                * @param type
                * @return
                */
               private boolean isRelational(int type) {
                       if ((type > 39) && (type < 60)){
                               return true;
+                      }
                       return false;
+              }
               /**
                * Return true if is a logical operator
                * @param type
                * @return
                */
               private boolean isLogical(int type){
                       if ((type > 9) && (type < 20)){
                               return true;
+                      }
                       return false;
+              }
               /**
                * Return true if is a seperator
                * @param type
                * @return
                */
               private boolean isSeparator(int type){
                       if ((type > 59) && (type < 70)){
                               return true;
+                      }
                       return false;
+              }
               /**
                * Divide a line in a set of words
                * @param line
                * Line to divide
                * @param option
                * If the option is EXACT it returns the same line
                * @return Iteraror
                * A set of words
                */
               public Iterator parseValues(String line, int option) {
                       Vector values = new Vector();
                       if (option == CONCORDANCIA_EXACT) {
                               values.add(line);
                               return values.iterator();
+                      }
                       StringTokenizer doubleQuotesTokenizer = new StringTokenizer(line, "\"",
                                       true);
                       boolean inside = false;
                       while (doubleQuotesTokenizer.hasMoreTokens()) {
                               String token = doubleQuotesTokenizer.nextToken();
                               if (token.equals("\"")) {
                                       inside = !inside;
                               } else if (inside) {
                                       values.add(token);
                               } else {
                                       StringTokenizer spaceTokenizer = new StringTokenizer(token, " ");
                                       while (spaceTokenizer.hasMoreTokens()) {
                                               String value = spaceTokenizer.nextToken();
                                               values.add(value);
+                                      }
+                              }
+                      }
                       return values.iterator();
+              }
+      }