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.collection.Array;
00032
00039 public final class SodaIntIndexComparator extends SodaIndexComparator {
00040 private Array comparatorList;
00041
00042 class IntOperande {
00043 int comparator=0;
00044 int operande;
00045 int traversal;
00046
00047 IntOperande() {
00048 }
00049 }
00053 public SodaIntIndexComparator() {
00054 super();
00055 comparatorList = new Array();
00056 }
00057
00058 public boolean setOperand(Object ope) {
00059 if (ope instanceof Integer) {
00060 IntOperande operand = new IntOperande();
00061 operand.operande = ((Integer)ope).intValue();
00062 comparatorList.add(operand);
00063 return true;
00064 }
00065 return false;
00066 }
00067
00068 public void mergeIndexComporator(SodaIndexComparator index) {
00069 SodaIntIndexComparator newindex = (SodaIntIndexComparator)index;
00070 comparatorList.addArray(newindex.comparatorList);
00071 }
00072
00073 public boolean addComparator(int comparator) {
00074 IntOperande comp = (IntOperande) comparatorList.getLastAdded();
00075 if (comp != null) {
00076 if (comp.comparator == BaseConstraint.COMPARATOR_NONE) {
00077 comp.comparator = comparator;
00078 comp.traversal = this.getTraversalWayWithComparator(comp.comparator);
00079 } else {
00080
00081 if (comp.comparator == BaseConstraint.EQUALS) {
00082 if (comparator == BaseConstraint.SMALLER) {
00083 comp.comparator = BaseConstraint.EQUALSMALLER;
00084 } else if (comparator == BaseConstraint.GREATER) {
00085 comp.comparator = BaseConstraint.EQUALGREATER;
00086 } else if (comparator == BaseConstraint.NOT) {
00087 comp.comparator = BaseConstraint.NOT;
00088 } else if (comparator == BaseConstraint.EQUALS) {
00089 comp.comparator = BaseConstraint.EQUALS;
00090 }
00091 } else if (comp.comparator == BaseConstraint.NOT) {
00092 if (comparator == BaseConstraint.SMALLER) {
00093 comp.comparator = BaseConstraint.EQUALGREATER;
00094 } else if (comparator == BaseConstraint.GREATER) {
00095 comp.comparator = BaseConstraint.EQUALSMALLER;
00096 } else if (comparator == BaseConstraint.EQUALS) {
00097 comp.comparator = BaseConstraint.NOT;
00098 } else if (comparator == BaseConstraint.NOT) {
00099 comp.comparator = BaseConstraint.NOT;
00100 }
00101 } else if (comp.comparator == BaseConstraint.SMALLER) {
00102 if (comparator == BaseConstraint.NOT) {
00103 comp.comparator = BaseConstraint.EQUALGREATER;
00104 } else if (comparator == BaseConstraint.EQUALS) {
00105 comp.comparator = BaseConstraint.EQUALSMALLER;
00106 } else if (comparator == BaseConstraint.GREATER) {
00107 comp.comparator = BaseConstraint.EQUALS;
00108 } else if (comparator == BaseConstraint.SMALLER) {
00109 comp.comparator = BaseConstraint.SMALLER;
00110 }
00111 } else if (comp.comparator == BaseConstraint.GREATER) {
00112 if (comparator == BaseConstraint.NOT) {
00113 comp.comparator = BaseConstraint.EQUALSMALLER;
00114 } else if (comparator == BaseConstraint.EQUALS) {
00115 comp.comparator = BaseConstraint.EQUALGREATER;
00116 } else if (comparator == BaseConstraint.SMALLER) {
00117 comp.comparator = BaseConstraint.EQUALS;
00118 } else if (comparator == BaseConstraint.GREATER) {
00119 comp.comparator = BaseConstraint.GREATER;
00120 }
00121 } else {
00122 IntOperande operand = new IntOperande();
00123 operand.operande = comp.operande;
00124 operand.comparator = comparator;
00125 operand.traversal = this.getTraversalWayWithComparator(operand.comparator);
00126 comparatorList.add(operand);
00127 }
00128 }
00129 return true;
00130 }
00131 return false;
00132 }
00133
00134 public int getSearchAlgo() {
00135 if (comparatorList.size() == 0) {
00136 return SodaIndexComparator.FULL_TRAVERSAL;
00137 } else {
00138 return ((IntOperande) comparatorList.get(0)).traversal;
00139 }
00140 }
00141
00146 public boolean isSelected(int searchInt) {
00147 boolean ret = true;
00148 int size = comparatorList.size();
00149 for (int i = 0; i < size && ret; i++) {
00150 ret = this.selectFisrtOperande((IntOperande) comparatorList.get(i), searchInt);
00151 }
00152 return ret;
00153 }
00154
00159 public int compareTo(int searchInt) {
00160 if (comparatorList.size() == 0) {
00161 return -1;
00162 } else {
00163 return this.compareFisrtOperande((IntOperande) comparatorList.get(0), searchInt);
00164 }
00165 }
00166
00167 private boolean selectFisrtOperande(IntOperande op, int key) {
00168 int test = key - op.operande;
00169 switch (op.comparator) {
00170 case BaseConstraint.EQUALS :
00171 return (test==0) ;
00172 case BaseConstraint.SMALLER :
00173 return (test <0) ;
00174 case BaseConstraint.EQUALSMALLER :
00175 return (test <=0) ;
00176 case BaseConstraint.GREATER :
00177 return (test >0) ;
00178 case BaseConstraint.EQUALGREATER :
00179 return (test >=0) ;
00180 case BaseConstraint.NOT :
00181 return (test != 0) ;
00182 }
00183 return true;
00184 }
00185
00186 private int compareFisrtOperande(IntOperande op, int key) {
00187 switch (op.comparator) {
00188 case BaseConstraint.EQUALS :
00189 case BaseConstraint.SMALLER :
00190 case BaseConstraint.EQUALSMALLER :
00191 case BaseConstraint.NOT :
00192 return key - op.operande ;
00193 case BaseConstraint.GREATER :
00194 case BaseConstraint.EQUALGREATER :
00195 return op.operande - key ;
00196 }
00197 return key - op.operande;
00198 }
00199
00200 }