KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > org > jboss > mq > selectors > Operator


1 /*
2 * JBoss, Home of Professional Open Source
3 * Copyright 2005, JBoss Inc., and individual contributors as indicated
4 * by the @authors tag. See the copyright.txt in the distribution for a
5 * full listing of individual contributors.
6 *
7 * This is free software; you can redistribute it and/or modify it
8 * under the terms of the GNU Lesser General Public License as
9 * published by the Free Software Foundation; either version 2.1 of
10 * the License, or (at your option) any later version.
11 *
12 * This software is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
16 *
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with this software; if not, write to the Free
19 * Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
20 * 02110-1301 USA, or see the FSF site: http://www.fsf.org.
21 */

22 package org.jboss.mq.selectors;
23
24 import java.util.HashSet JavaDoc;
25
26 import org.jboss.util.Primitives;
27
28 /**
29  * An operator for the selector system.
30  *
31  * @author Norbert Lataille (Norbert.Lataille@m4x.org)
32  * @author droy@boostmyscore.com
33  * @author Scott.Stark@jboss.org
34  * @author adrian@jboss.com
35  * @created August 16, 2001
36  * @version $Revision: 37459 $
37  */

38 public class Operator
39 {
40    int operation;
41    Object JavaDoc oper1;
42    Object JavaDoc oper2;
43    Object JavaDoc oper3;
44
45    Object JavaDoc arg1;
46    Object JavaDoc arg2;
47    Object JavaDoc arg3;
48
49    int class1;
50    int class2;
51    int class3;
52    
53    // info about the regular expression
54
// if this is a LIKE operator
55
// (perhaps this should be a subclass)
56
RegExp re = null;
57
58    public final static int EQUAL = 0;
59    public final static int NOT = 1;
60    public final static int AND = 2;
61    public final static int OR = 3;
62    public final static int GT = 4;
63    public final static int GE = 5;
64    public final static int LT = 6;
65    public final static int LE = 7;
66    public final static int DIFFERENT = 8;
67    public final static int ADD = 9;
68    public final static int SUB = 10;
69    public final static int NEG = 11;
70    public final static int MUL = 12;
71    public final static int DIV = 13;
72    public final static int BETWEEN = 14;
73    public final static int NOT_BETWEEN = 15;
74    public final static int LIKE = 16;
75    public final static int NOT_LIKE = 17;
76    public final static int LIKE_ESCAPE = 18;
77    public final static int NOT_LIKE_ESCAPE = 19;
78    public final static int IS_NULL = 20;
79    public final static int IS_NOT_NULL = 21;
80    public final static int IN = 22;
81    public final static int NOT_IN = 23;
82
83    public final static int STRING = 0;
84    public final static int DOUBLE = 1;
85    //DOUBLE FLOAT
86
public final static int LONG = 2;
87    //LONG BYTE SHORT INTEGER
88
public final static int BOOLEAN = 3;
89
90    public Operator(int operation, Object JavaDoc oper1, Object JavaDoc oper2, Object JavaDoc oper3)
91    {
92       this.operation = operation;
93       this.oper1 = oper1;
94       this.oper2 = oper2;
95       this.oper3 = oper3;
96    }
97
98    public Operator(int operation, Object JavaDoc oper1, Object JavaDoc oper2)
99    {
100       this.operation = operation;
101       this.oper1 = oper1;
102       this.oper2 = oper2;
103       this.oper3 = null;
104    }
105
106    public Operator(int operation, Object JavaDoc oper1)
107    {
108       this.operation = operation;
109       this.oper1 = oper1;
110       this.oper2 = null;
111       this.oper3 = null;
112    }
113
114    //--- Print functions ---
115

116    public String JavaDoc toString()
117    {
118       return print("");
119    }
120
121    public String JavaDoc print(String JavaDoc level)
122    {
123       String JavaDoc st = level + operation + ":" + operationString(operation) + "(\n";
124
125       String JavaDoc nextLevel = level + " ";
126
127       if (oper1 == null)
128          st += nextLevel + "null\n";
129       else if (oper1 instanceof Operator)
130          st += ((Operator) oper1).print( nextLevel );
131       else
132          st += nextLevel + oper1.toString() + "\n";
133
134       if (oper2 != null)
135       {
136          if (oper2 instanceof Operator)
137             st += ((Operator) oper2).print(nextLevel);
138          else
139             st += nextLevel + oper2.toString() + "\n";
140       }
141
142       if (oper3 != null)
143       {
144          if (oper3 instanceof Operator)
145             st += ((Operator) oper3).print(nextLevel);
146          else
147             st += nextLevel + oper3.toString() + "\n";
148       }
149
150       st += level + ")\n";
151
152       return st;
153    }
154
155
156    //Operator 20
157
Object JavaDoc is_null() throws Exception JavaDoc
158    {
159       computeArgument1();
160       if (arg1 == null)
161          return Boolean.TRUE;
162       else
163          return Boolean.FALSE;
164    }
165
166    //Operator 21
167
Object JavaDoc is_not_null() throws Exception JavaDoc
168    {
169       computeArgument1();
170       if (arg1 != null)
171          return Boolean.TRUE;
172       else
173          return Boolean.FALSE;
174    }
175
176    //Operation 0
177
Object JavaDoc equal() throws Exception JavaDoc
178    {
179       computeArgument1();
180       if (arg1 == null)
181          return Boolean.FALSE;
182
183       switch (class1)
184       {
185          case LONG:
186             computeArgument1();
187             if (arg1 == null)
188                return null;
189             computeArgument2();
190             if (arg2 == null)
191                return null;
192             if (class2 == LONG)
193                return Primitives.valueOf(((Number JavaDoc) arg1).longValue() == ((Number JavaDoc) arg2).longValue());
194             if (class2 == DOUBLE)
195                return Primitives.valueOf(((Number JavaDoc) arg1).longValue() == ((Number JavaDoc) arg2).doubleValue());
196             return Boolean.FALSE;
197          case DOUBLE:
198             computeArgument1();
199             if (arg1 == null)
200                return null;
201             computeArgument2();
202             if (arg2 == null)
203                return null;
204             if (class2 == LONG)
205                return Primitives.valueOf(((Number JavaDoc) arg1).doubleValue() == ((Number JavaDoc) arg2).longValue());
206             if (class2 == DOUBLE)
207                return Primitives.valueOf(((Number JavaDoc) arg1).doubleValue() == ((Number JavaDoc) arg2).doubleValue());
208             return Boolean.FALSE;
209          case STRING:
210          case BOOLEAN:
211             computeArgument2();
212             if (arg2 == null)
213                return Boolean.FALSE;
214             if (class2 != class1)
215                throwBadObjectException(class1, class2);
216             return Primitives.valueOf(arg1.equals(arg2));
217          default:
218             throwBadObjectException(class1);
219             return null;
220       }
221
222    }
223
224    //Operation 1
225
Object JavaDoc not() throws Exception JavaDoc
226    {
227       computeArgument1();
228       if (arg1 == null)
229          return null;
230       if (class1 != BOOLEAN)
231          throwBadObjectException(class1);
232       if (((Boolean JavaDoc)arg1).booleanValue())
233          return Boolean.FALSE;
234       else
235          return Boolean.TRUE;
236    }
237
238    //Operation 2
239
Object JavaDoc and() throws Exception JavaDoc
240    {
241       computeArgument1();
242       if (arg1 == null)
243       {
244          computeArgument2();
245          if (arg2 == null)
246             return null;
247          if (class2 != BOOLEAN)
248             throwBadObjectException(class2);
249          if (((Boolean JavaDoc) arg2).booleanValue() == false )
250             return Boolean.FALSE;
251          return null;
252       }
253
254       if (class1 == BOOLEAN)
255       {
256          if (((Boolean JavaDoc) arg1).booleanValue() == false)
257             return Boolean.FALSE;
258          computeArgument2();
259          if (arg2 == null)
260             return null;
261          if (class2 != BOOLEAN)
262             throwBadObjectException(class2);
263          return arg2;
264       }
265
266       throwBadObjectException(class1);
267       return null;
268    }
269
270    /**
271     * Operation 3
272     *
273     * | OR | T | F | U
274     * +------+-------+-------+--------
275     * | T | T | T | T
276     * | F | T | F | U
277     * | U | T | U | U
278     * +------+-------+-------+-------
279     */

280    Object JavaDoc or() throws Exception JavaDoc
281    {
282       short falseCounter=0;
283       
284       computeArgument1();
285       if (arg1 != null)
286       {
287          if (class1 != BOOLEAN)
288             throwBadObjectException(class1);
289          if (((Boolean JavaDoc) arg1).booleanValue())
290             return Boolean.TRUE;
291          else
292             falseCounter++;
293       }
294
295       computeArgument2();
296       if (arg2 != null)
297       {
298          if (class2 != BOOLEAN)
299             throwBadObjectException(class2);
300          if (((Boolean JavaDoc)arg2).booleanValue())
301             return Boolean.TRUE;
302          else
303             falseCounter++;
304       }
305
306       if (falseCounter == 2)
307         return Boolean.FALSE;
308       
309       return null;
310    }
311
312    //Operation 4
313
Object JavaDoc gt() throws Exception JavaDoc
314    {
315       computeArgument1();
316       if (arg1 == null)
317          return null;
318
319       if (class1 == LONG)
320       {
321          computeArgument2();
322          if (arg2 == null)
323             return null;
324          if (class2 == LONG)
325             return Primitives.valueOf(((Number JavaDoc) arg1).longValue() > ((Number JavaDoc) arg2).longValue());
326          if (class2 == DOUBLE)
327             return Primitives.valueOf(((Number JavaDoc) arg1).longValue() > ((Number JavaDoc) arg2).doubleValue());
328       }
329       else if ( class1 == DOUBLE )
330       {
331          computeArgument2();
332          if (arg2 == null)
333             return null;
334          if (class2 == LONG)
335             return Primitives.valueOf(((Number JavaDoc) arg1).doubleValue() > ((Number JavaDoc) arg2).longValue());
336          if (class2 == DOUBLE)
337             return Primitives.valueOf(((Number JavaDoc) arg1).doubleValue() > ((Number JavaDoc) arg2).doubleValue());
338          return Boolean.FALSE;
339       }
340       return Boolean.FALSE;
341    }
342
343    //Operation 5
344
Object JavaDoc ge() throws Exception JavaDoc
345    {
346       computeArgument1();
347       if (arg1 == null)
348          return null;
349
350       if (class1 == LONG)
351       {
352          computeArgument2();
353          if (arg2 == null)
354             return null;
355          if (class2 == LONG)
356             return Primitives.valueOf(((Number JavaDoc) arg1).longValue() >= ((Number JavaDoc) arg2).longValue());
357          if (class2 == DOUBLE)
358             return Primitives.valueOf(((Number JavaDoc) arg1).longValue() >= ((Number JavaDoc) arg2).doubleValue());
359       }
360       else if ( class1 == DOUBLE )
361       {
362          computeArgument2();
363          if (arg2 == null)
364             return null;
365          if (class2 == LONG)
366             return Primitives.valueOf(((Number JavaDoc) arg1).longValue() >= ((Number JavaDoc) arg2).longValue());
367          if (class2 == DOUBLE)
368             return Primitives.valueOf(((Number JavaDoc) arg1).doubleValue() >= ((Number JavaDoc) arg2).doubleValue());
369          return Boolean.FALSE;
370       }
371       return Boolean.FALSE;
372    }
373
374    //Operation 6
375
Object JavaDoc lt() throws Exception JavaDoc
376    {
377       computeArgument1();
378       if (arg1 == null)
379          return null;
380
381       if (class1 == LONG)
382       {
383          computeArgument2();
384          if (arg2 == null)
385             return null;
386          if (class2 == LONG)
387             return Primitives.valueOf(((Number JavaDoc) arg1).longValue() < ((Number JavaDoc) arg2).longValue());
388          if (class2 == DOUBLE)
389             return Primitives.valueOf(((Number JavaDoc) arg1).longValue() < ((Number JavaDoc) arg2).doubleValue());
390       }
391       else if (class1 == DOUBLE)
392       {
393          computeArgument2();
394          if (arg2 == null)
395             return null;
396          if (class2 == LONG)
397             return Primitives.valueOf(((Number JavaDoc) arg1).doubleValue() < ((Number JavaDoc) arg2).longValue());
398          if (class2 == DOUBLE)
399             return Primitives.valueOf(((Number JavaDoc) arg1).doubleValue() < ((Number JavaDoc) arg2).doubleValue());
400       }
401
402       return Boolean.FALSE;
403    }
404
405    //Operation 7
406
Object JavaDoc le() throws Exception JavaDoc
407    {
408       computeArgument1();
409       if (arg1 == null)
410          return null;
411
412       if (class1 == LONG)
413       {
414          computeArgument2();
415          if (arg2 == null)
416             return null;
417          if (class2 == LONG)
418             return Primitives.valueOf(((Number JavaDoc) arg1).longValue() <= ((Number JavaDoc) arg2).longValue());
419          if (class2 == DOUBLE)
420             return Primitives.valueOf(((Number JavaDoc) arg1).longValue() <= ((Number JavaDoc) arg2).doubleValue());
421       }
422       else if (class1 == DOUBLE)
423       {
424          computeArgument2();
425          if (arg2 == null)
426             return null;
427          if (class2 == LONG)
428             return Primitives.valueOf(((Number JavaDoc) arg1).doubleValue() <= ((Number JavaDoc) arg2).longValue());
429          if (class2 == DOUBLE)
430             return Primitives.valueOf(((Number JavaDoc) arg1).doubleValue() <= ((Number JavaDoc) arg2).doubleValue());
431       }
432       return Boolean.FALSE;
433    }
434
435    //Operation 8
436
Object JavaDoc different() throws Exception JavaDoc
437    {
438       computeArgument1();
439       if ( arg1 == null )
440          return Boolean.FALSE;
441
442       switch (class1)
443       {
444          case LONG:
445             computeArgument1();
446             if (arg1 == null)
447                return null;
448             computeArgument2();
449             if (arg2 == null)
450                return null;
451             if (class2 == LONG)
452                return Primitives.valueOf(((Number JavaDoc) arg1).longValue() != ((Number JavaDoc) arg2).longValue());
453             if (class2 == DOUBLE)
454                return Primitives.valueOf(((Number JavaDoc) arg1).longValue() != ((Number JavaDoc) arg2).doubleValue());
455             return Boolean.FALSE;
456          case DOUBLE:
457             computeArgument1();
458             if (arg1 == null)
459                return null;
460             computeArgument2();
461             if (arg2 == null)
462                return null;
463             if (class2 == LONG)
464                return Primitives.valueOf(((Number JavaDoc) arg1).doubleValue() != ((Number JavaDoc) arg2).longValue());
465             if (class2 == DOUBLE)
466                return Primitives.valueOf(((Number JavaDoc) arg1).doubleValue() != ((Number JavaDoc) arg2).doubleValue());
467             return Boolean.FALSE;
468          case STRING:
469          case BOOLEAN:
470             computeArgument2();
471             if (arg2 == null)
472                return Boolean.FALSE;
473             if (class2 != class1)
474                throwBadObjectException(class1, class2);
475             return Primitives.valueOf(arg1.equals(arg2) == false);
476          default:
477             throwBadObjectException(class1);
478       }
479       return null;
480    }
481
482    //Operator 9
483
Object JavaDoc add() throws Exception JavaDoc
484    {
485       computeArgument1();
486       computeArgument2();
487
488       if (arg1 == null || arg2 == null)
489          return null;
490       switch (class1)
491       {
492          case DOUBLE:
493             switch (class2)
494             {
495                case DOUBLE:
496                   return new Double JavaDoc(((Number JavaDoc) arg1).doubleValue() + ((Number JavaDoc) arg2).doubleValue());
497                case LONG:
498                   return new Double JavaDoc(((Number JavaDoc) arg1).doubleValue() + ((Number JavaDoc) arg2).doubleValue());
499                default:
500                   throwBadObjectException(class2);
501             }
502          case LONG:
503             switch (class2)
504             {
505                case DOUBLE:
506                   return new Double JavaDoc(((Number JavaDoc) arg1).doubleValue() + ((Number JavaDoc) arg2).doubleValue());
507                case LONG:
508                   return new Long JavaDoc(((Number JavaDoc) arg1).longValue() + ((Number JavaDoc) arg2).longValue());
509                default:
510                   throwBadObjectException(class2);
511             }
512          default:
513             throwBadObjectException(class1);
514       }
515       return null;
516    }
517
518    //Operator 10
519
Object JavaDoc sub() throws Exception JavaDoc
520    {
521       computeArgument1();
522       computeArgument2();
523
524       if (arg1 == null || arg2 == null)
525          return null;
526       switch (class1)
527       {
528          case DOUBLE:
529             switch (class2)
530             {
531                case DOUBLE:
532                   return new Double JavaDoc(((Number JavaDoc) arg1).doubleValue() - ((Number JavaDoc) arg2).doubleValue());
533                case LONG:
534                   return new Double JavaDoc(((Number JavaDoc) arg1).doubleValue() - ((Number JavaDoc) arg2).doubleValue());
535                default:
536                   throwBadObjectException(class2);
537             }
538          case LONG:
539             switch (class2)
540             {
541                case DOUBLE:
542                   return new Double JavaDoc(((Number JavaDoc) arg1).doubleValue() - ((Number JavaDoc) arg2).doubleValue());
543                case LONG:
544                   return new Long JavaDoc(((Number JavaDoc) arg1).longValue() - ((Number JavaDoc) arg2).longValue());
545                default:
546                   throwBadObjectException(class2);
547             }
548          default:
549             throwBadObjectException(class1);
550       }
551       return null;
552    }
553
554    //Operator 11
555
Object JavaDoc neg() throws Exception JavaDoc
556    {
557       computeArgument1();
558       if (arg1 == null)
559          return null;
560       switch (class1)
561       {
562          case DOUBLE:
563             return new Double JavaDoc(-((Number JavaDoc) arg1).doubleValue());
564          case LONG:
565             return new Long JavaDoc(-((Number JavaDoc)arg1).longValue());
566          default:
567             throwBadObjectException(class1);
568       }
569       return null;
570    }
571
572    //Operator 12
573
Object JavaDoc mul() throws Exception JavaDoc
574    {
575       computeArgument1();
576       computeArgument2();
577       if (arg1 == null || arg2 == null)
578          return null;
579       switch (class1)
580       {
581          case DOUBLE:
582             switch (class2)
583             {
584                case DOUBLE:
585                   return new Double JavaDoc(((Number JavaDoc) arg1).doubleValue() * ((Number JavaDoc) arg2).doubleValue());
586                case LONG:
587                   return new Double JavaDoc(((Number JavaDoc) arg1).doubleValue() * ((Number JavaDoc) arg2).doubleValue());
588                default:
589                   throwBadObjectException(class2);
590             }
591          case LONG:
592             switch (class2)
593             {
594                case DOUBLE:
595                   return new Double JavaDoc(((Number JavaDoc) arg1).doubleValue() * ((Number JavaDoc) arg2).doubleValue());
596                case LONG:
597                   return new Long JavaDoc(((Number JavaDoc) arg1).longValue() * ((Number JavaDoc) arg2).longValue());
598                default:
599                   throwBadObjectException(class2);
600             }
601          default:
602             throwBadObjectException(class1);
603       }
604       return null;
605    }
606
607    //Operator 13
608
Object JavaDoc div() throws Exception JavaDoc
609    {
610       //Can throw Divide by zero exception...
611
computeArgument1();
612       computeArgument2();
613       if (arg1 == null || arg2 == null)
614          return null;
615       switch (class1)
616       {
617          case DOUBLE:
618             switch (class2)
619             {
620                case DOUBLE:
621                   return new Double JavaDoc(((Number JavaDoc) arg1).doubleValue() / ((Number JavaDoc) arg2).doubleValue());
622                case LONG:
623                   return new Double JavaDoc(((Number JavaDoc) arg1).doubleValue() / ((Number JavaDoc) arg2).doubleValue());
624                default:
625                   throwBadObjectException(class2);
626             }
627          case LONG:
628             switch (class2)
629             {
630                case DOUBLE:
631                   return new Double JavaDoc(((Number JavaDoc) arg1).doubleValue() / ((Number JavaDoc) arg2).doubleValue());
632                case LONG:
633                   return new Long JavaDoc(((Number JavaDoc) arg1).longValue() / ((Number JavaDoc) arg2).longValue());
634                default:
635                   throwBadObjectException(class2);
636             }
637          default:
638             throwBadObjectException(class1);
639       }
640       return null;
641    }
642
643    //Operator 14
644
Object JavaDoc between() throws Exception JavaDoc
645    {
646       Object JavaDoc res = ge();
647       if (res == null)
648          return null;
649       if (((Boolean JavaDoc) res).booleanValue() == false)
650          return res;
651
652       Object JavaDoc oper4 = oper2;
653       oper2 = oper3;
654       res = le();
655       oper2 = oper4;
656       return res;
657    }
658
659    //Operator 15
660
Object JavaDoc not_between() throws Exception JavaDoc
661    {
662       Object JavaDoc res = lt();
663       if (res == null)
664          return null;
665       if (((Boolean JavaDoc) res).booleanValue())
666          return res;
667
668       Object JavaDoc oper4 = oper2;
669       oper2 = oper3;
670       res = gt();
671       oper2 = oper4;
672       return res;
673    }
674
675    //Operation 16,17,18,19
676
/**
677     * Handle LIKE, NOT LIKE, LIKE ESCAPE, and NOT LIKE ESCAPE operators.
678     *
679     * @param not true if this is a NOT LIKE construct, false if this
680     * is a LIKE construct.
681     * @param use_escape true if this is a LIKE ESCAPE construct, false if
682     * there is no ESCAPE clause
683     * @return Description of the Returned Value
684     * @exception Exception Description of Exception
685     */

686    Object JavaDoc like(boolean not, boolean use_escape) throws Exception JavaDoc
687    {
688       Character JavaDoc escapeChar = null;
689
690       computeArgument1();
691       if (arg1 == null)
692          return null;
693       if (class1 != STRING)
694          throwBadObjectException(class1);
695
696       computeArgument2();
697       if (arg2 == null)
698          return null;
699       if (class2 != STRING)
700          throwBadObjectException(class2);
701
702       if (use_escape)
703       {
704          computeArgument3();
705          if (arg3 == null)
706             return null;
707
708          if (class3 != STRING)
709             throwBadObjectException(class3);
710
711          StringBuffer JavaDoc escapeBuf = new StringBuffer JavaDoc((String JavaDoc) arg3);
712          if (escapeBuf.length() != 1)
713             throw new Exception JavaDoc("LIKE ESCAPE: Bad escape character " + escapeBuf.toString());
714
715          escapeChar = new Character JavaDoc(escapeBuf.charAt(0));
716       }
717
718       if (re == null)
719          // the first time through we prepare the regular expression
720
re = new RegExp ((String JavaDoc) arg2, escapeChar);
721       
722       boolean result = re.isMatch (arg1);
723       if (not)
724          result = !result;
725       
726       if (result == true)
727          return Boolean.TRUE;
728       else
729          return Boolean.FALSE;
730    }
731
732    //Operator 22
733
Object JavaDoc in() throws Exception JavaDoc
734    {
735       computeArgument1();
736       if (arg1 == null)
737          return null;
738       if (((HashSet JavaDoc) oper2).contains(arg1))
739          return Boolean.TRUE;
740       else
741          return Boolean.FALSE;
742    }
743
744    //Operator 23
745
Object JavaDoc not_in() throws Exception JavaDoc
746    {
747       computeArgument1();
748       if (arg1 == null)
749          return null;
750       if (class1 != STRING)
751          throwBadObjectException(class1);
752       if (((HashSet JavaDoc) oper2).contains(arg1))
753          return Boolean.FALSE;
754       else
755          return Boolean.TRUE;
756    }
757
758
759    void computeArgument1() throws Exception JavaDoc
760    {
761       Class JavaDoc className = oper1.getClass();
762
763       if (className == Identifier.class)
764          arg1 = ((Identifier) oper1).value;
765       else if (className == Operator.class)
766          arg1 = ((Operator) oper1).apply();
767       else
768          arg1 = oper1;
769
770       if (arg1 == null)
771       {
772          class1 = 0;
773          return;
774       }
775
776       className = arg1.getClass();
777
778       if (className == String JavaDoc.class)
779          class1 = STRING;
780       else if (className == Double JavaDoc.class)
781          class1 = DOUBLE;
782       else if (className == Long JavaDoc.class)
783          class1 = LONG;
784       else if (className == Integer JavaDoc.class)
785       {
786          class1 = LONG;
787          arg1 = new Long JavaDoc(((Integer JavaDoc) arg1).longValue());
788       }
789       else if (className == Short JavaDoc.class)
790       {
791          class1 = LONG;
792          arg1 = new Long JavaDoc(((Short JavaDoc) arg1).longValue());
793       }
794       else if (className == Byte JavaDoc.class)
795       {
796          class1 = LONG;
797          arg1 = new Long JavaDoc(((Byte JavaDoc) arg1).longValue());
798       }
799       else if (className == Float JavaDoc.class)
800       {
801          class1 = DOUBLE;
802          arg1 = new Double JavaDoc(((Float JavaDoc) arg1).doubleValue());
803       }
804       else if (className == Boolean JavaDoc.class)
805          class1 = BOOLEAN;
806       else
807          throwBadObjectException(className);
808    }
809
810    void computeArgument2() throws Exception JavaDoc
811    {
812       Class JavaDoc className = oper2.getClass();
813
814       if (className == Identifier.class)
815          arg2 = ((Identifier) oper2).value;
816       else if (className == Operator.class)
817          arg2 = ((Operator) oper2).apply();
818       else
819          arg2 = oper2;
820
821       if (arg2 == null)
822       {
823          class2 = 0;
824          return;
825       }
826
827       className = arg2.getClass();
828
829       if (className == String JavaDoc.class)
830          class2 = STRING;
831       else if (className == Double JavaDoc.class)
832          class2 = DOUBLE;
833       else if (className == Long JavaDoc.class)
834          class2 = LONG;
835       else if (className == Integer JavaDoc.class)
836       {
837          class2 = LONG;
838          arg2 = new Long JavaDoc(((Integer JavaDoc) arg2).longValue());
839       }
840       else if (className == Short JavaDoc.class)
841       {
842          class2 = LONG;
843          arg2 = new Long JavaDoc(((Short JavaDoc) arg2).longValue());
844       }
845       else if (className == Byte JavaDoc.class)
846       {
847          class2 = LONG;
848          arg2 = new Long JavaDoc(((Byte JavaDoc) arg2).longValue());
849       }
850       else if (className == Float JavaDoc.class)
851       {
852          class2 = DOUBLE;
853          arg2 = new Double JavaDoc(((Float JavaDoc) arg2).doubleValue());
854       }
855       else if (className == Boolean JavaDoc.class)
856          class2 = BOOLEAN;
857       else
858          throwBadObjectException(className);
859    }
860
861    void computeArgument3() throws Exception JavaDoc
862    {
863       Class JavaDoc className = oper3.getClass();
864
865       if (className == Identifier.class)
866          arg3 = ((Identifier) oper3).value;
867       else if (className == Operator.class)
868          arg3 = ((Operator ) oper3).apply();
869       else
870          arg3 = oper3;
871
872       if (arg3 == null)
873       {
874          class3 = 0;
875          return;
876       }
877
878       className = arg3.getClass();
879
880       if (className == String JavaDoc.class)
881          class3 = STRING;
882       else if (className == Double JavaDoc.class)
883          class3 = DOUBLE;
884       else if (className == Long JavaDoc.class)
885          class3 = LONG;
886       else if (className == Integer JavaDoc.class)
887       {
888          class3 = LONG;
889          arg3 = new Long JavaDoc(((Integer JavaDoc) arg3).longValue());
890       }
891       else if (className == Short JavaDoc.class)
892       {
893          class3 = LONG;
894          arg3 = new Long JavaDoc(((Short JavaDoc) arg3).longValue());
895       }
896       else if (className == Byte JavaDoc.class)
897       {
898          class3 = LONG;
899          arg3 = new Long JavaDoc(((Byte JavaDoc) arg3).longValue());
900       }
901       else if (className == Float JavaDoc.class)
902       {
903          class3 = DOUBLE;
904          arg3 = new Double JavaDoc(((Float JavaDoc) arg3).doubleValue());
905       }
906       else if (className == Boolean JavaDoc.class)
907          class3 = BOOLEAN;
908       else
909          throwBadObjectException(className);
910    }
911
912    public Object JavaDoc apply() throws Exception JavaDoc
913    {
914       switch (operation)
915       {
916          case EQUAL:
917             return equal();
918          case NOT:
919             return not();
920          case AND:
921             return and();
922          case OR:
923             return or();
924          case GT:
925             return gt();
926          case GE:
927             return ge();
928          case LT:
929             return lt();
930          case LE:
931             return le();
932          case DIFFERENT:
933             return different();
934          case ADD:
935             return add();
936          case SUB:
937             return sub();
938          case NEG:
939             return neg();
940          case MUL:
941             return mul();
942          case DIV:
943             return div();
944          case BETWEEN:
945             return between();
946          case NOT_BETWEEN:
947             return not_between();
948          case LIKE:
949             return like(false, false);
950          case NOT_LIKE:
951             return like(true, false);
952          case LIKE_ESCAPE:
953             return like(false, true);
954          case NOT_LIKE_ESCAPE:
955             return like(true, true);
956          case IS_NULL:
957             return is_null();
958          case IS_NOT_NULL:
959             return is_not_null();
960          case IN:
961             return in();
962          case NOT_IN:
963             return not_in();
964       }
965
966       throw new Exception JavaDoc("Unknown operation: " + toString());
967    }
968
969    public void throwBadObjectException(Class JavaDoc class1) throws Exception JavaDoc
970    {
971       throw new Exception JavaDoc("Bad Object: '" + class1.getName() + "' for operation: " + toString());
972    }
973
974    public void throwBadObjectException(int class1) throws Exception JavaDoc
975    {
976       throw new Exception JavaDoc("Bad Object: '" + getClassName(class1) + "' for operation: " + toString());
977    }
978
979    public void throwBadObjectException(int class1, int class2) throws Exception JavaDoc
980    {
981       throw new Exception JavaDoc("Bad Object: expected '" + getClassName(class1) + "' got '" + getClassName(class2) + "' for operation: " + toString());
982    }
983
984    static String JavaDoc getClassName(int class1)
985    {
986       String JavaDoc str = "Unknown";
987       switch (class1)
988       {
989          case STRING:
990             str = "String";
991             break;
992          case LONG:
993             str = "Long";
994             break;
995          case DOUBLE:
996             str = "Double";
997             break;
998          case BOOLEAN:
999             str = "Boolean";
1000            break;
1001      }
1002      return str;
1003   }
1004
1005   static String JavaDoc operationString(int operation)
1006   {
1007      String JavaDoc str = "Unknown";
1008      switch( operation )
1009      {
1010         case EQUAL:
1011            str = "EQUAL";
1012            break;
1013         case NOT:
1014            str = "NOT";
1015            break;
1016         case AND:
1017            str = "AND";
1018            break;
1019         case OR:
1020            str = "OR";
1021            break;
1022         case GT:
1023            str = "GT";
1024            break;
1025         case GE:
1026            str = "GE";
1027            break;
1028         case LT:
1029            str = "LT";
1030            break;
1031         case LE:
1032            str = "LE";
1033            break;
1034         case DIFFERENT:
1035            str = "DIFFERENT";
1036            break;
1037         case ADD:
1038            str = "ADD";
1039            break;
1040         case SUB:
1041            str = "SUB";
1042            break;
1043         case NEG:
1044            str = "NEG";
1045            break;
1046         case MUL:
1047            str = "MUL";
1048            break;
1049         case DIV:
1050            str = "DIV";
1051            break;
1052         case BETWEEN:
1053            str = "BETWEEN";
1054            break;
1055         case NOT_BETWEEN:
1056            str = "NOT_BETWEEN";
1057            break;
1058         case LIKE:
1059            str = "LIKE";
1060            break;
1061         case NOT_LIKE:
1062            str = "NOT_LIKE";
1063            break;
1064         case LIKE_ESCAPE:
1065            str = "LIKE_ESCAPE";
1066            break;
1067         case NOT_LIKE_ESCAPE:
1068            str = "NOT_LIKE_ESCAPE";
1069            break;
1070         case IS_NULL:
1071            str = "IS_NULL";
1072            break;
1073         case IS_NOT_NULL:
1074            str = "IS_NOT_NULL";
1075            break;
1076         case IN:
1077            str = "IN";
1078            break;
1079         case NOT_IN:
1080            str = "NOT_IN";
1081            break;
1082      }
1083      return str;
1084   }
1085}
1086
Popular Tags