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 ;
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 oper1;
42    Object oper2;
43    Object oper3;
44
45    Object arg1;
46    Object arg2;
47    Object 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 oper1, Object oper2, Object 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 oper1, Object 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 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 toString()
117    {
118       return print("");
119    }
120
121    public String print(String level)
122    {
123       String st = level + operation + ":" + operationString(operation) + "(\n";
124
125       String 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 is_null() throws Exception
158    {
159       computeArgument1();
160       if (arg1 == null)
161          return Boolean.TRUE;
162       else
163          return Boolean.FALSE;
164    }
165
166    //Operator 21
167 Object is_not_null() throws Exception
168    {
169       computeArgument1();
170       if (arg1 != null)
171          return Boolean.TRUE;
172       else
173          return Boolean.FALSE;
174    }
175
176    //Operation 0
177 Object equal() throws Exception
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 ) arg1).longValue() == ((Number ) arg2).longValue());
194             if (class2 == DOUBLE)
195                return Primitives.valueOf(((Number ) arg1).longValue() == ((Number ) 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 ) arg1).doubleValue() == ((Number ) arg2).longValue());
206             if (class2 == DOUBLE)
207                return Primitives.valueOf(((Number ) arg1).doubleValue() == ((Number ) 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 not() throws Exception
226    {
227       computeArgument1();
228       if (arg1 == null)
229          return null;
230       if (class1 != BOOLEAN)
231          throwBadObjectException(class1);
232       if (((Boolean )arg1).booleanValue())
233          return Boolean.FALSE;
234       else
235          return Boolean.TRUE;
236    }
237
238    //Operation 2
239 Object and() throws Exception
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 ) arg2).booleanValue() == false )
250             return Boolean.FALSE;
251          return null;
252       }
253
254       if (class1 == BOOLEAN)
255       {
256          if (((Boolean ) 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 or() throws Exception
281    {
282       short falseCounter=0;
283       
284       computeArgument1();
285       if (arg1 != null)
286       {
287          if (class1 != BOOLEAN)
288             throwBadObjectException(class1);
289          if (((Boolean ) 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 )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 gt() throws Exception
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 ) arg1).longValue() > ((Number ) arg2).longValue());
326          if (class2 == DOUBLE)
327             return Primitives.valueOf(((Number ) arg1).longValue() > ((Number ) 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 ) arg1).doubleValue() > ((Number ) arg2).longValue());
336          if (class2 == DOUBLE)
337             return Primitives.valueOf(((Number ) arg1).doubleValue() > ((Number ) arg2).doubleValue());
338          return Boolean.FALSE;
339       }
340       return Boolean.FALSE;
341    }
342
343    //Operation 5
344 Object ge() throws Exception
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 ) arg1).longValue() >= ((Number ) arg2).longValue());
357          if (class2 == DOUBLE)
358             return Primitives.valueOf(((Number ) arg1).longValue() >= ((Number ) 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 ) arg1).longValue() >= ((Number ) arg2).longValue());
367          if (class2 == DOUBLE)
368             return Primitives.valueOf(((Number ) arg1).doubleValue() >= ((Number ) arg2).doubleValue());
369          return Boolean.FALSE;
370       }
371       return Boolean.FALSE;
372    }
373
374    //Operation 6
375 Object lt() throws Exception
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 ) arg1).longValue() < ((Number ) arg2).longValue());
388          if (class2 == DOUBLE)
389             return Primitives.valueOf(((Number ) arg1).longValue() < ((Number ) 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 ) arg1).doubleValue() < ((Number ) arg2).longValue());
398          if (class2 == DOUBLE)
399             return Primitives.valueOf(((Number ) arg1).doubleValue() < ((Number ) arg2).doubleValue());
400       }
401
402       return Boolean.FALSE;
403    }
404
405    //Operation 7
406 Object le() throws Exception
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 ) arg1).longValue() <= ((Number ) arg2).longValue());
419          if (class2 == DOUBLE)
420             return Primitives.valueOf(((Number ) arg1).longValue() <= ((Number ) 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 ) arg1).doubleValue() <= ((Number ) arg2).longValue());
429          if (class2 == DOUBLE)
430             return Primitives.valueOf(((Number ) arg1).doubleValue() <= ((Number ) arg2).doubleValue());
431       }
432       return Boolean.FALSE;
433    }
434
435    //Operation 8
436 Object different() throws Exception
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 ) arg1).longValue() != ((Number ) arg2).longValue());
453             if (class2 == DOUBLE)
454                return Primitives.valueOf(((Number ) arg1).longValue() != ((Number ) 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 ) arg1).doubleValue() != ((Number ) arg2).longValue());
465             if (class2 == DOUBLE)
466                return Primitives.valueOf(((Number ) arg1).doubleValue() != ((Number ) 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 add() throws Exception
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 (((Number ) arg1).doubleValue() + ((Number ) arg2).doubleValue());
497                case LONG:
498                   return new Double (((Number ) arg1).doubleValue() + ((Number ) arg2).doubleValue());
499                default:
500                   throwBadObjectException(class2);
501             }
502          case LONG:
503             switch (class2)
504             {
505                case DOUBLE:
506                   return new Double (((Number ) arg1).doubleValue() + ((Number ) arg2).doubleValue());
507                case LONG:
508                   return new Long (((Number ) arg1).longValue() + ((Number ) arg2).longValue());
509                default:
510                   throwBadObjectException(class2);
511             }
512          default:
513             throwBadObjectException(class1);
514       }
515       return null;
516    }
517
518    //Operator 10
519 Object sub() throws Exception
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 (((Number ) arg1).doubleValue() - ((Number ) arg2).doubleValue());
533                case LONG:
534                   return new Double (((Number ) arg1).doubleValue() - ((Number ) arg2).doubleValue());
535                default:
536                   throwBadObjectException(class2);
537             }
538          case LONG:
539             switch (class2)
540             {
541                case DOUBLE:
542                   return new Double (((Number ) arg1).doubleValue() - ((Number ) arg2).doubleValue());
543                case LONG:
544                   return new Long (((Number ) arg1).longValue() - ((Number ) arg2).longValue());
545                default:
546                   throwBadObjectException(class2);
547             }
548          default:
549             throwBadObjectException(class1);
550       }
551       return null;
552    }
553
554    //Operator 11
555 Object neg() throws Exception
556    {
557       computeArgument1();
558       if (arg1 == null)
559          return null;
560       switch (class1)
561       {
562          case DOUBLE:
563             return new Double (-((Number ) arg1).doubleValue());
564          case LONG:
565             return new Long (-((Number )arg1).longValue());
566          default:
567             throwBadObjectException(class1);
568       }
569       return null;
570    }
571
572    //Operator 12
573 Object mul() throws Exception
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 (((Number ) arg1).doubleValue() * ((Number ) arg2).doubleValue());
586                case LONG:
587                   return new Double (((Number ) arg1).doubleValue() * ((Number ) arg2).doubleValue());
588                default:
589                   throwBadObjectException(class2);
590             }
591          case LONG:
592             switch (class2)
593             {
594                case DOUBLE:
595                   return new Double (((Number ) arg1).doubleValue() * ((Number ) arg2).doubleValue());
596                case LONG:
597                   return new Long (((Number ) arg1).longValue() * ((Number ) arg2).longValue());
598                default:
599                   throwBadObjectException(class2);
600             }
601          default:
602             throwBadObjectException(class1);
603       }
604       return null;
605    }
606
607    //Operator 13
608 Object div() throws Exception
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 (((Number ) arg1).doubleValue() / ((Number ) arg2).doubleValue());
622                case LONG:
623                   return new Double (((Number ) arg1).doubleValue() / ((Number ) arg2).doubleValue());
624                default:
625                   throwBadObjectException(class2);
626             }
627          case LONG:
628             switch (class2)
629             {
630                case DOUBLE:
631                   return new Double (((Number ) arg1).doubleValue() / ((Number ) arg2).doubleValue());
632                case LONG:
633                   return new Long (((Number ) arg1).longValue() / ((Number ) arg2).longValue());
634                default:
635                   throwBadObjectException(class2);
636             }
637          default:
638             throwBadObjectException(class1);
639       }
640       return null;
641    }
642
643    //Operator 14
644 Object between() throws Exception
645    {
646       Object res = ge();
647       if (res == null)
648          return null;
649       if (((Boolean ) res).booleanValue() == false)
650          return res;
651
652       Object oper4 = oper2;
653       oper2 = oper3;
654       res = le();
655       oper2 = oper4;
656       return res;
657    }
658
659    //Operator 15
660 Object not_between() throws Exception
661    {
662       Object res = lt();
663       if (res == null)
664          return null;
665       if (((Boolean ) res).booleanValue())
666          return res;
667
668       Object 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 like(boolean not, boolean use_escape) throws Exception
687    {
688       Character 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 escapeBuf = new StringBuffer ((String ) arg3);
712          if (escapeBuf.length() != 1)
713             throw new Exception ("LIKE ESCAPE: Bad escape character " + escapeBuf.toString());
714
715          escapeChar = new Character (escapeBuf.charAt(0));
716       }
717
718       if (re == null)
719          // the first time through we prepare the regular expression
720 re = new RegExp ((String ) 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 in() throws Exception
734    {
735       computeArgument1();
736       if (arg1 == null)
737          return null;
738       if (((HashSet ) oper2).contains(arg1))
739          return Boolean.TRUE;
740       else
741          return Boolean.FALSE;
742    }
743
744    //Operator 23
745 Object not_in() throws Exception
746    {
747       computeArgument1();
748       if (arg1 == null)
749          return null;
750       if (class1 != STRING)
751          throwBadObjectException(class1);
752       if (((HashSet ) oper2).contains(arg1))
753          return Boolean.FALSE;
754       else
755          return Boolean.TRUE;
756    }
757
758
759    void computeArgument1() throws Exception
760    {
761       Class