00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028
00029 package org.openmobileis.database.fastobjectdb.db.query.soda;
00030
00031 import org.openmobileis.common.util.StringFormater;
00032 import org.openmobileis.common.util.collection.Array;
00033
00040 public final class SodaStringIndexComparator extends SodaIndexComparator {
00041 private Array comparatorList;
00042 private boolean isCaseSensitive = false;
00043 private boolean isDistinct;
00044
00045 class StringOperande {
00046 int comparator;
00047 String operande;
00048 int traversal;
00049
00050 StringOperande() {
00051 }
00052 }
00053
00057 public SodaStringIndexComparator(boolean caseSensitive) {
00058 super();
00059 this.comparatorList = new Array();
00060 this.isCaseSensitive = caseSensitive;
00061 }
00062
00063 public boolean setOperand(Object ope) {
00064 if (ope instanceof String) {
00065 StringOperande operand = new StringOperande();
00066 operand.operande = (String)ope;
00067 if (!this.isCaseSensitive) {
00068 operand.operande = StringFormater.removeAccent(operand.operande).toUpperCase();
00069 }
00070 comparatorList.add(operand);
00071 return true;
00072 }
00073 return false;
00074 }
00075
00076 public void mergeIndexComporator(SodaIndexComparator index) {
00077 SodaStringIndexComparator newindex = (SodaStringIndexComparator)index;
00078 comparatorList.add(newindex.comparatorList);
00079 }
00080
00081 public boolean addComparator(int comparator) {
00082 if (comparator == BaseConstraint.DISTINCT) {
00083 this.setDistinct(true);
00084 }
00085 StringOperande comp = (StringOperande) comparatorList.getLastAdded();
00086 if (comp != null) {
00087 if (comp.comparator == BaseConstraint.COMPARATOR_NONE) {
00088 comp.comparator = comparator;
00089 comp.traversal = this.getTraversalWayWithComparator(comp.comparator);
00090 } else {
00091
00092 if (comp.comparator == BaseConstraint.EQUALS) {
00093 if (comparator == BaseConstraint.SMALLER) {
00094 comp.comparator = BaseConstraint.EQUALSMALLER;
00095 } else if (comparator == BaseConstraint.GREATER) {
00096 comp.comparator = BaseConstraint.EQUALGREATER;
00097 } else if (comparator == BaseConstraint.NOT) {
00098 comp.comparator = BaseConstraint.NOT;
00099 } else if (comparator == BaseConstraint.EQUALS) {
00100 comp.comparator = BaseConstraint.EQUALS;
00101 }
00102 } else if (comp.comparator == BaseConstraint.NOT) {
00103 if (comparator == BaseConstraint.SMALLER) {
00104 comp.comparator = BaseConstraint.EQUALGREATER;
00105 } else if (comparator == BaseConstraint.GREATER) {
00106 comp.comparator = BaseConstraint.EQUALSMALLER;
00107 } else if (comparator == BaseConstraint.EQUALS) {
00108 comp.comparator = BaseConstraint.NOT;
00109 } else if (comparator == BaseConstraint.NOT) {
00110 comp.comparator = BaseConstraint.NOT;
00111 }
00112 } else if (comp.comparator == BaseConstraint.SMALLER) {
00113 if (comparator == BaseConstraint.NOT) {
00114 comp.comparator = BaseConstraint.EQUALGREATER;
00115 } else if (comparator == BaseConstraint.EQUALS) {
00116 comp.comparator = BaseConstraint.EQUALSMALLER;
00117 } else if (comparator == BaseConstraint.GREATER) {
00118 comp.comparator = BaseConstraint.EQUALS;
00119 } else if (comparator == BaseConstraint.SMALLER) {
00120 comp.comparator = BaseConstraint.SMALLER;
00121 }
00122 } else if (comp.comparator == BaseConstraint.GREATER) {
00123 if (comparator == BaseConstraint.NOT) {
00124 comp.comparator = BaseConstraint.EQUALSMALLER;
00125 } else if (comparator == BaseConstraint.EQUALS) {
00126 comp.comparator = BaseConstraint.EQUALGREATER;
00127 } else if (comparator == BaseConstraint.SMALLER) {
00128 comp.comparator = BaseConstraint.EQUALS;
00129 } else if (comparator == BaseConstraint.GREATER) {
00130 comp.comparator = BaseConstraint.GREATER;
00131 }
00132 } else {
00133 StringOperande operand = new StringOperande();
00134 operand.operande = comp.operande;
00135 operand.comparator = comparator;
00136 operand.traversal = this.getTraversalWayWithComparator(operand.comparator);
00137 comparatorList.add(operand);
00138 }
00139 }
00140 return true;
00141 }
00142
00143 return false;
00144 }
00145
00146 public int getSearchAlgo() {
00147 if (comparatorList.size() == 0) {
00148 return SodaIndexComparator.FULL_TRAVERSAL;
00149 } else {
00150 return ((StringOperande) comparatorList.get(0)).traversal;
00151 }
00152 }
00153
00158 public boolean isSelected(String searchString) {
00159 boolean ret = true;
00160 int size = comparatorList.size();
00161 for (int i = 0; i < size && ret; i++) {
00162 ret = this.selectFisrtOperande((StringOperande) comparatorList.get(i), searchString);
00163 }
00164 return ret;
00165 }
00166
00171 public int compareTo(String searchString) {
00172 if (comparatorList.size() == 0) {
00173 return -1;
00174 } else {
00175 return this.compareFisrtOperande((StringOperande) comparatorList.get(0), searchString);
00176 }
00177 }
00178
00179 private boolean selectFisrtOperande(StringOperande op, String key) {
00180 switch (op.comparator) {
00181 case BaseConstraint.EQUALS :
00182 int test = key.compareTo(op.operande);
00183 return (test==0) ;
00184 case BaseConstraint.NOT :
00185 test = key.compareTo(op.operande);
00186 return (test!=0) ;
00187 case BaseConstraint.SMALLER :
00188 test = key.compareTo(op.operande);
00189 return (test <0) ;
00190 case BaseConstraint.EQUALSMALLER :
00191 test = key.compareTo(op.operande);
00192 return (test <=0) ;
00193 case BaseConstraint.GREATER :
00194 test = key.compareTo(op.operande);
00195 return (test >0) ;
00196 case BaseConstraint.EQUALGREATER :
00197 test = key.compareTo(op.operande);
00198 return (test >=0) ;
00199 case BaseConstraint.LIKE :
00200 return key.startsWith(op.operande) ;
00201 case BaseConstraint.CONTAINS :
00202 return (key.indexOf(op.operande)!=-1) ;
00203 case BaseConstraint.DISTINCT :
00204 return true ;
00205 }
00206 return true;
00207 }
00208
00209 private int compareFisrtOperande(StringOperande op, String key) {
00210 switch (op.comparator) {
00211 case BaseConstraint.EQUALS :
00212 case BaseConstraint.SMALLER :
00213 case BaseConstraint.EQUALSMALLER :
00214 case BaseConstraint.LIKE :
00215 case BaseConstraint.NOT :
00216 return key.compareTo(op.operande) ;
00217 case BaseConstraint.EQUALGREATER :
00218 case BaseConstraint.GREATER :
00219 return -key.compareTo(op.operande) ;
00220 case BaseConstraint.CONTAINS :
00221 case BaseConstraint.DISTINCT :
00222 return -1 ;
00223 }
00224 return -1;
00225 }
00226
00227 public boolean isDistinct() {
00228 return isDistinct;
00229 }
00230 public void setDistinct(boolean isDistinct) {
00231 this.isDistinct = isDistinct;
00232 }
00233 }