|
1
21 package com.db4o.nativequery.expr.build;
22
23 import com.db4o.nativequery.expr.*;
24 import com.db4o.nativequery.expr.cmp.*;
25
26 public class ExpressionBuilder {
27
30 public Expression not(Expression expr) {
31 if(expr.equals(BoolConstExpression.TRUE)) {
32 return BoolConstExpression.FALSE;
33 }
34 if(expr.equals(BoolConstExpression.FALSE)) {
35 return BoolConstExpression.TRUE;
36 }
37 if(expr instanceof NotExpression) {
38 return ((NotExpression)expr).expr();
39 }
40 if(expr instanceof ComparisonExpression) {
41 ComparisonExpression cmpExpr=(ComparisonExpression)expr;
42 if(cmpExpr.right() instanceof ConstValue) {
43 ConstValue rightConst=(ConstValue)cmpExpr.right();
44 if(rightConst.value() instanceof Boolean  ) {
45 Boolean boolVal=(Boolean )rightConst.value();
46 return new ComparisonExpression(cmpExpr.left(),new ConstValue(new Boolean (!boolVal.booleanValue())),cmpExpr.op());
48 }
49 }
50 }
51 return new NotExpression(expr);
52 }
53
54
57 public Expression and(Expression left, Expression right) {
58 if(left.equals(BoolConstExpression.FALSE)||right.equals(BoolConstExpression.FALSE)) {
59 return BoolConstExpression.FALSE;
60 }
61 if(left.equals(BoolConstExpression.TRUE)) {
62 return right;
63 }
64 if(right.equals(BoolConstExpression.TRUE)) {
65 return left;
66 }
67 if(left.equals(right)) {
68 return left;
69 }
70 if(negatives(left,right)) {
71 return BoolConstExpression.FALSE;
72 }
73 return new AndExpression(left,right);
74 }
75
76
79 public Expression or(Expression left, Expression right) {
80 if(left.equals(BoolConstExpression.TRUE)||right.equals(BoolConstExpression.TRUE)) {
81 return BoolConstExpression.TRUE;
82 }
83 if(left.equals(BoolConstExpression.FALSE)) {
84 return right;
85 }
86 if(right.equals(BoolConstExpression.FALSE)) {
87 return left;
88 }
89 if(left.equals(right)) {
90 return left;
91 }
92 if(negatives(left,right)) {
93 return BoolConstExpression.TRUE;
94 }
95 return new OrExpression(left,right);
96 }
97
98
101 public BoolConstExpression constant(Boolean value) {
102 return BoolConstExpression.expr(value.booleanValue());
103 }
104
105 public Expression ifThenElse(Expression cond, Expression truePath, Expression falsePath) {
106 Expression expr=checkBoolean(cond,truePath,falsePath);
107 if(expr!=null) {
108 return expr;
109 }
110 return or(and(cond,truePath),and(not(cond),falsePath));
111 }
112
113 private Expression checkBoolean(Expression cmp,Expression trueExpr,Expression falseExpr) {
114 if(cmp instanceof BoolConstExpression) {
115 return null;
116 }
117 if(trueExpr instanceof BoolConstExpression) {
118 boolean leftNegative=trueExpr.equals(BoolConstExpression.FALSE);
119 if(!leftNegative) {
120 return or(cmp,falseExpr);
121 }
122 else {
123 return and(not(cmp),falseExpr);
124 }
125 }
126 if(falseExpr instanceof BoolConstExpression) {
127 boolean rightNegative=falseExpr.equals(BoolConstExpression.FALSE);
128 if(!rightNegative) {
129 return and(cmp,trueExpr);
130 }
131 else {
132 return or(not(cmp),falseExpr);
133 }
134 }
135 if(cmp instanceof NotExpression) {
136 cmp=((NotExpression)cmp).expr();
137 Expression swap=trueExpr;
138 trueExpr=falseExpr;
139 falseExpr=swap;
140 }
141 if(trueExpr instanceof OrExpression) {
142 OrExpression orExpr=(OrExpression)trueExpr;
143 Expression orLeft=orExpr.left();
144 Expression orRight=orExpr.right();
145 if(falseExpr.equals(orRight)) {
146 Expression swap=orRight;
147 orRight=orLeft;
148 orLeft=swap;
149 }
150 if(falseExpr.equals(orLeft)) {
151 return or(orLeft,and(cmp,orRight));
152 }
153 }
154 if(falseExpr instanceof AndExpression) {
155 AndExpression andExpr=(AndExpression)falseExpr;
156 Expression andLeft=andExpr.left();
157 Expression andRight=andExpr.right();
158 if(trueExpr.equals(andRight)) {
159 Expression swap=andRight;
160 andRight=andLeft;
161 andLeft=swap;
162 }
163 if(trueExpr.equals(andLeft)) {
164 return and(andLeft,or(cmp,andRight));
165 }
166 }
167 return null;
168 }
169
170 private boolean negatives(Expression left,Expression right) {
171 return negativeOf(left,right)||negativeOf(right,left);
172 }
173
174 private boolean negativeOf(Expression right, Expression left) {
175 return (right instanceof NotExpression)&&((NotExpression)right).expr().equals(left);
176 }
177 }
178 |
Popular Tags |
Java API By Example, From Geeks To Geeks.