001: /**
002: * Copyright 2006 Webmedia Group Ltd.
003: *
004: * Licensed under the Apache License, Version 2.0 (the "License");
005: * you may not use this file except in compliance with the License.
006: * You may obtain a copy of the License at
007: *
008: * http://www.apache.org/licenses/LICENSE-2.0
009: *
010: * Unless required by applicable law or agreed to in writing, software
011: * distributed under the License is distributed on an "AS IS" BASIS,
012: * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
013: * See the License for the specific language governing permissions and
014: * limitations under the License.
015: **/package org.araneaframework.uilib.list.structure.filter.advanced;
016:
017: import java.util.Arrays;
018: import java.util.Comparator;
019: import java.util.Map;
020: import org.araneaframework.backend.list.memorybased.Expression;
021: import org.araneaframework.backend.list.memorybased.ExpressionBuilder;
022: import org.araneaframework.backend.list.memorybased.expression.LaxyExpressionIterator;
023: import org.araneaframework.uilib.form.Control;
024: import org.araneaframework.uilib.form.FormElement;
025: import org.araneaframework.uilib.list.structure.filter.BaseFilter;
026: import org.araneaframework.uilib.list.structure.filter.FilterContext;
027: import org.araneaframework.uilib.list.structure.filter.atomic.Constant;
028: import org.araneaframework.uilib.list.structure.filter.atomic.Field;
029: import org.araneaframework.uilib.list.structure.filter.atomic.Value;
030: import org.araneaframework.uilib.list.util.ExpressionUtil;
031: import org.araneaframework.uilib.list.util.FilterFormUtil;
032:
033: public abstract class SqlFunctionFilter extends BaseFilter {
034:
035: private static final long serialVersionUID = 1L;
036:
037: // creating filter
038:
039: public static SqlFunctionFilter getFieldEqualInstance(
040: FilterContext ctx, String fieldId, String functionName,
041: ExpressionBuilder[] functionParams) {
042: return initField(createEqual(), ctx, fieldId, functionName,
043: functionParams);
044: }
045:
046: public static SqlFunctionFilter getFieldGreaterThanInstance(
047: FilterContext ctx, String fieldId, String functionName,
048: ExpressionBuilder[] functionParams) {
049: return initField(createGreaterThan(ctx), ctx, fieldId,
050: functionName, functionParams);
051: }
052:
053: public static SqlFunctionFilter getFieldLowerThanInstance(
054: FilterContext ctx, String fieldId, String functionName,
055: ExpressionBuilder[] functionParams) {
056: return initField(createLowerThan(ctx), ctx, fieldId,
057: functionName, functionParams);
058: }
059:
060: public static SqlFunctionFilter getValueEqualInstance(
061: FilterContext ctx, String valueId, String functionName,
062: ExpressionBuilder[] functionParams) {
063: return initValue(createEqual(), ctx, valueId, functionName,
064: functionParams);
065: }
066:
067: public static SqlFunctionFilter getValueGreaterThanInstance(
068: FilterContext ctx, String valueId, String functionName,
069: ExpressionBuilder[] functionParams) {
070: return initValue(createGreaterThan(ctx), ctx, valueId,
071: functionName, functionParams);
072: }
073:
074: public static SqlFunctionFilter getValueLowerThanInstance(
075: FilterContext ctx, String valueId, String functionName,
076: ExpressionBuilder[] functionParams) {
077: return initValue(createLowerThan(ctx), ctx, valueId,
078: functionName, functionParams);
079: }
080:
081: public static SqlFunctionFilter getConstantEqualInstance(
082: FilterContext ctx, String valueId, Object value,
083: String functionName, ExpressionBuilder[] functionParams) {
084: return initConstant(createEqual(), ctx, valueId, value,
085: functionName, functionParams);
086: }
087:
088: public static SqlFunctionFilter getConstantGreaterThanInstance(
089: FilterContext ctx, String valueId, Object value,
090: String functionName, ExpressionBuilder[] functionParams) {
091: return initConstant(createGreaterThan(ctx), ctx, valueId,
092: value, functionName, functionParams);
093: }
094:
095: public static SqlFunctionFilter getConstantLowerThanInstance(
096: FilterContext ctx, String valueId, Object value,
097: String functionName, ExpressionBuilder[] functionParams) {
098: return initConstant(createLowerThan(ctx), ctx, valueId, value,
099: functionName, functionParams);
100: }
101:
102: private static SqlFunctionFilter createEqual() {
103: return new Equal();
104: }
105:
106: private static SqlFunctionFilter createGreaterThan(FilterContext ctx) {
107: SqlFunctionFilter filter;
108: if (ctx.isStrict()) {
109: filter = new GreaterThan();
110: } else {
111: filter = new GreaterThanOrEquals();
112: }
113: return filter;
114: }
115:
116: private static SqlFunctionFilter createLowerThan(FilterContext ctx) {
117: SqlFunctionFilter filter;
118: if (ctx.isStrict()) {
119: filter = new LowerThan();
120: } else {
121: filter = new LowerThanOrEquals();
122: }
123: return filter;
124: }
125:
126: private static SqlFunctionFilter initField(
127: SqlFunctionFilter filter, FilterContext ctx,
128: String fieldId, String functionName,
129: ExpressionBuilder[] functionParams) {
130: filter.setOperand(new Field(fieldId));
131: return init(filter, ctx, fieldId, functionName, functionParams);
132: }
133:
134: private static SqlFunctionFilter initValue(
135: SqlFunctionFilter filter, FilterContext ctx,
136: String valueId, String functionName,
137: ExpressionBuilder[] functionParams) {
138: filter.setOperand(new Value(valueId));
139: return init(filter, ctx, valueId, functionName, functionParams);
140: }
141:
142: private static SqlFunctionFilter initConstant(
143: SqlFunctionFilter filter, FilterContext ctx,
144: String valueId, Object value, String functionName,
145: ExpressionBuilder[] functionParams) {
146: filter.setOperand(new Constant(valueId, value));
147: return init(filter, ctx, valueId, functionName, functionParams);
148: }
149:
150: private static SqlFunctionFilter init(SqlFunctionFilter filter,
151: FilterContext ctx, String fieldId, String functionName,
152: ExpressionBuilder[] functionParams) {
153: filter.setComparator(ctx.getFieldComparator(fieldId));
154: filter
155: .setProcedure(new Procedure(functionName,
156: functionParams));
157: return filter;
158: }
159:
160: // add to form
161:
162: public static void addToForm(FilterContext ctx, String id,
163: FormElement element) {
164: ctx.getForm().addElement(id, element);
165: }
166:
167: public static void addToForm(FilterContext ctx, String id,
168: Control control) {
169: addToForm(ctx, id, FilterFormUtil.createElement(ctx, id,
170: control));
171: }
172:
173: public static void addToForm(FilterContext ctx, String id) {
174: addToForm(ctx, id, FilterFormUtil.createElement(ctx, id));
175: }
176:
177: private ExpressionBuilder procedure;
178: private ExpressionBuilder operand;
179:
180: private Comparator comparator;
181:
182: public ExpressionBuilder getOperand() {
183: return operand;
184: }
185:
186: public void setOperand(ExpressionBuilder operand) {
187: this .operand = operand;
188: }
189:
190: public ExpressionBuilder getProcedure() {
191: return procedure;
192: }
193:
194: public void setProcedure(ExpressionBuilder procedure) {
195: this .procedure = procedure;
196: }
197:
198: public Comparator getComparator() {
199: return comparator;
200: }
201:
202: public void setComparator(Comparator comparator) {
203: this .comparator = comparator;
204: }
205:
206: static class Procedure implements ExpressionBuilder {
207: private static final long serialVersionUID = 1L;
208:
209: private String name;
210: private ExpressionBuilder[] params;
211:
212: public Procedure(String name, ExpressionBuilder[] params) {
213: this .name = name;
214: this .params = params;
215: }
216:
217: public Expression buildExpression(Map data) {
218: return ExpressionUtil.sqlFunction(name,
219: new LaxyExpressionIterator(Arrays.asList(params)
220: .iterator(), data));
221: }
222: }
223:
224: public static class Equal extends SqlFunctionFilter {
225: public Expression buildExpression(Map data) {
226: return ExpressionUtil.eq(
227: getOperand().buildExpression(data), getProcedure()
228: .buildExpression(data), getComparator());
229: }
230: }
231:
232: public static class GreaterThan extends SqlFunctionFilter {
233: public Expression buildExpression(Map data) {
234: return ExpressionUtil.gt(
235: getOperand().buildExpression(data), getProcedure()
236: .buildExpression(data), getComparator());
237: }
238: }
239:
240: public static class LowerThan extends SqlFunctionFilter {
241: public Expression buildExpression(Map data) {
242: return ExpressionUtil.lt(
243: getOperand().buildExpression(data), getProcedure()
244: .buildExpression(data), getComparator());
245: }
246: }
247:
248: public static class GreaterThanOrEquals extends SqlFunctionFilter {
249: public Expression buildExpression(Map data) {
250: return ExpressionUtil.ge(
251: getOperand().buildExpression(data), getProcedure()
252: .buildExpression(data), getComparator());
253: }
254: }
255:
256: public static class LowerThanOrEquals extends SqlFunctionFilter {
257: public Expression buildExpression(Map data) {
258: return ExpressionUtil.le(
259: getOperand().buildExpression(data), getProcedure()
260: .buildExpression(data), getComparator());
261: }
262: }
263: }
|