001 /* Query.java -- Static methods for query construction.
002 Copyright (C) 2007 Free Software Foundation, Inc.
003
004 This file is part of GNU Classpath.
005
006 GNU Classpath is free software; you can redistribute it and/or modify
007 it under the terms of the GNU General Public License as published by
008 the Free Software Foundation; either version 2, or (at your option)
009 any later version.
010
011 GNU Classpath is distributed in the hope that it will be useful, but
012 WITHOUT ANY WARRANTY; without even the implied warranty of
013 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
014 General Public License for more details.
015
016 You should have received a copy of the GNU General Public License
017 along with GNU Classpath; see the file COPYING. If not, write to the
018 Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
019 02110-1301 USA.
020
021 Linking this library statically or dynamically with other modules is
022 making a combined work based on this library. Thus, the terms and
023 conditions of the GNU General Public License cover the whole
024 combination.
025
026 As a special exception, the copyright holders of this library give you
027 permission to link this library with independent modules to produce an
028 executable, regardless of the license terms of these independent
029 modules, and to copy and distribute the resulting executable under
030 terms of your choice, provided that you also meet, for each linked
031 independent module, the terms and conditions of the license of that
032 module. An independent module is a module which is not derived from
033 or based on this library. If you modify this library, you may extend
034 this exception to your version of the library, but you are not
035 obligated to do so. If you do not wish to do so, delete this
036 exception statement from your version. */
037
038 package javax.management;
039
040 /**
041 * Provides static methods for constructing queries. Queries
042 * may be used to list and enumerate management beans, via
043 * the {@link MBeanServer}. By using the methods in this class,
044 * complex queries can be created from their more basic
045 * components.
046 *
047 * @author Andrew John Hughes (gnu_andrew@member.fsf.org)
048 * @since 1.5
049 */
050 public class Query
051 {
052
053 /**
054 * A code representing the {@link #plus(ValueExp, ValueExp)
055 * query to be used in serialization.
056 */
057 public static final int PLUS = 0;
058
059 /**
060 * A code representing the {@link #minus(ValueExp, ValueExp)
061 * query to be used in serialization.
062 */
063 public static final int MINUS = 1;
064
065 /**
066 * A code representing the {@link #times(ValueExp, ValueExp)
067 * query to be used in serialization.
068 */
069 public static final int TIMES = 2;
070
071 /**
072 * A code representing the {@link #div(ValueExp, ValueExp)
073 * query to be used in serialization.
074 */
075 public static final int DIV = 3;
076
077 /**
078 * A code representing the {@link #gt(ValueExp, ValueExp)
079 * query to be used in serialization.
080 */
081 public static final int GT = 0;
082
083 /**
084 * A code representing the {@link #lt(ValueExp, ValueExp)
085 * query to be used in serialization.
086 */
087 public static final int LT = 1;
088
089 /**
090 * A code representing the {@link #ge(ValueExp, ValueExp)
091 * query to be used in serialization.
092 */
093 public static final int GE = 2;
094
095 /**
096 * A code representing the {@link #le(ValueExp, ValueExp)
097 * query to be used in serialization.
098 */
099 public static final int LE = 3;
100
101 /**
102 * A code representing the {@link #eq(ValueExp, ValueExp)
103 * query to be used in serialization.
104 */
105 public static final int EQ = 4;
106
107 /**
108 * Returns a query expression formed from the conjunction
109 * of the two supplied query expressions.
110 *
111 * @param q1 the first query expression.
112 * @param q2 the second query expression.
113 * @return a query expression representing q1 && q2. This
114 * will be serialized as the non-public class
115 * {@link AndQueryExp}.
116 */
117 public static QueryExp and(QueryExp q1, QueryExp q2)
118 {
119 return new AndQueryExp(q1, q2);
120 }
121
122 /**
123 * Returns a query expression which checks that an
124 * attribute value held by the specified
125 * {@link AttributeValueExp} contains the string
126 * specified by the given {@link StringValueExp}.
127 *
128 * @param attrib the attribute to match.
129 * @param string the substring to find.
130 * @return a query expression representing
131 * <code>attrib.matches("*" + string + "*")</code>.
132 * This will be serialized as the non-public class
133 * {@link MatchQueryExp}.
134 */
135 public static QueryExp anySubString(AttributeValueExp attrib,
136 StringValueExp string)
137 {
138 return new MatchQueryExp(attrib, "*" + string.getValue() + "*");
139 }
140
141 /**
142 * Returns a value expression for the value of the
143 * named attribute. Evaluating this using an
144 * {@link ObjectName} involves an underlying call
145 * to {@link MBeanServer#getAttribute(ObjectName,String)}.
146 *
147 * @param name the name of the attribute.
148 * @return a value expression which returns the value
149 * of the named attribute when applied.
150 */
151 public static AttributeValueExp attr(String name)
152 {
153 return new AttributeValueExp(name);
154 }
155
156 /**
157 * Returns a value expression for the value of the
158 * named attribute from the specified class. Evaluating
159 * this using an {@link ObjectName} involves an underlying call
160 * to both {@link MBeanServer#getObjectInstance(ObjectName)} and
161 * {@link MBeanServer#getAttribute(ObjectName,String)}.
162 *
163 * @param className the class containing the attribute.
164 * @param name the name of the attribute.
165 * @return a value expression which returns the value
166 * of the named attribute when applied.
167 * This will be serialized as the non-public class
168 * {@link QualifiedAttributeValueExp}.
169 */
170 public static AttributeValueExp attr(String className,
171 String name)
172 {
173 return new QualifiedAttributeValueExp(className, name);
174 }
175
176 /**
177 * Returns a query expression representing the constraint
178 * that the value, <code>v1</code>, lies between <code>v2</code>
179 * and <code>v3</code>.
180 *
181 * @param v1 the value to compare against the boundaries.
182 * @param v2 the lower boundary.
183 * @param v3 the upper boundary.
184 * @return a query expression representing a comparison
185 * of <code>v1</code> against <code>v2</code>
186 * and <code>v3</code>. It returns true if
187 * <code>v2 <= v1 <= v3</code>. This
188 * will be serialized as the non-public class
189 * {@link BetweenQueryExp}.
190 */
191 public static QueryExp between(ValueExp v1, ValueExp v2,
192 ValueExp v3)
193 {
194 return new BetweenQueryExp(v1, v2, v3);
195 }
196
197 /**
198 * Returns a value expression which evaluates to the name of
199 * the class of the bean when applied. Associating the expression
200 * with an {@link ObjectName} involves an underlying call
201 * to both {@link MBeanServer#getObjectInstance(ObjectName)}
202 * to obtain this information.
203 *
204 * @return a value expression which returns the class name
205 * of the bean to which it is applied.
206 * This will be serialized as the non-public class
207 * {@link ClassAttributeValueExp}.
208 */
209 public static AttributeValueExp classattr()
210 {
211 return new ClassAttributeValueExp();
212 }
213
214 /**
215 * Returns a value expression which evaluates to the result of
216 * dividing <code>v1</code> by <code>v2</code>.
217 *
218 * @param v1 the left-hand operand.
219 * @param v2 the right-hand operand.
220 * @return a value expression which returns the result of
221 * the division when applied. This will be serialized
222 * as the non-public class {@link BinaryOpValueExp}
223 * with an operation of {@link #DIV}.
224 */
225 public static ValueExp div(ValueExp v1, ValueExp v2)
226 {
227 return new BinaryOpValueExp(DIV, v1, v2);
228 }
229
230 /**
231 * Returns a query expression which evaluates to the result of
232 * comparing <code>v1</code> to <code>v2</code> for equality.
233 *
234 * @param v1 the left-hand operand.
235 * @param v2 the right-hand operand.
236 * @return a value expression which returns the result of
237 * the comparison when applied. This will be serialized
238 * as the non-public class {@link BinaryRelQueryExp}
239 * with an operation of {@link #EQ}.
240 */
241 public static QueryExp eq(ValueExp v1, ValueExp v2)
242 {
243 return new BinaryRelQueryExp(EQ, v1, v2);
244 }
245
246 /**
247 * Returns a query expression which checks that an
248 * attribute value held by the specified
249 * {@link AttributeValueExp} ends with the string
250 * specified by the given {@link StringValueExp}.
251 *
252 * @param attrib the attribute to match.
253 * @param string the substring to find.
254 * @return a query expression representing
255 * <code>attrib.matches("*" + string)</code>.
256 * This will be serialized as the non-public class
257 * {@link MatchQueryExp}.
258 */
259 public static QueryExp finalSubString(AttributeValueExp attrib,
260 StringValueExp string)
261 {
262 return new MatchQueryExp(attrib, "*" + string.getValue());
263 }
264
265 /**
266 * Returns a query expression which evaluates to the result of
267 * comparing <code>v1</code> to <code>v2</code> to see if
268 * <code>v1</code> is greater than or equal to <code>v2</code>.
269 *
270 * @param v1 the left-hand operand.
271 * @param v2 the right-hand operand.
272 * @return a value expression which returns the result of
273 * the comparison when applied. This will be serialized
274 * as the non-public class {@link BinaryRelQueryExp}
275 * with an operation of {@link #GE}.
276 */
277 public static QueryExp geq(ValueExp v1, ValueExp v2)
278 {
279 return new BinaryRelQueryExp(GE, v1, v2);
280 }
281
282 /**
283 * Returns a query expression which evaluates to the result of
284 * comparing <code>v1</code> to <code>v2</code> to see if
285 * <code>v1</code> is greater than <code>v2</code>.
286 *
287 * @param v1 the left-hand operand.
288 * @param v2 the right-hand operand.
289 * @return a value expression which returns the result of
290 * the comparison when applied. This will be serialized
291 * as the non-public class {@link BinaryRelQueryExp}
292 * with an operation of {@link #GT}.
293 */
294 public static QueryExp gt(ValueExp v1, ValueExp v2)
295 {
296 return new BinaryRelQueryExp(GT, v1, v2);
297 }
298
299 /**
300 * Returns a query expression representing the constraint
301 * that the value, <code>v</code>, is a member of the
302 * list, <code>vlist</code>.
303 *
304 * @param v the value to look for in the list.
305 * @param vlist the list of allowed values.
306 * @return a query expression representing a membership check
307 * of <code>v</code> against the list, <code>vlist</code>.
308 * This will be serialized as the non-public class
309 * {@link InQueryExp}.
310 */
311 public static QueryExp in(ValueExp v, ValueExp[] vlist)
312 {
313 return new InQueryExp(v, vlist);
314 }
315
316 /**
317 * Returns a query expression which checks that an
318 * attribute value held by the specified
319 * {@link AttributeValueExp} starts with the string
320 * specified by the given {@link StringValueExp}.
321 *
322 * @param attrib the attribute to match.
323 * @param string the substring to find.
324 * @return a query expression representing
325 * <code>attrib.matches(string + "*")</code>.
326 * This will be serialized as the non-public class
327 * {@link MatchQueryExp}.
328 */
329 public static QueryExp initialSubString(AttributeValueExp attrib,
330 StringValueExp string)
331 {
332 return new MatchQueryExp(attrib, string.getValue() + "*");
333 }
334
335 /**
336 * Returns a query expression which checks that a
337 * bean is an instance of the class specified
338 * by the given {@link StringValueExp}. Associating the
339 * expression with an {@link ObjectName} involves an underlying
340 * call to {@link MBeanServer#isInstanceOf(ObjectName, String)}
341 * using the value of <code>((StringValueExp)
342 * className.apply(objectName)).getValue()</code> as the
343 * class name.
344 *
345 * @param className the name of the class which the bean
346 * should be an instance of.
347 * @return a query expression representing
348 * the inheritance check. This will be serialized
349 * as the non-public class {@link InstanceOfQueryExp}.
350 * @since 1.6
351 */
352 public static QueryExp isInstanceOf(StringValueExp className)
353 {
354 return new InstanceOfQueryExp(className);
355 }
356
357 /**
358 * Returns a query expression which evaluates to the result of
359 * comparing <code>v1</code> to <code>v2</code> to see if
360 * <code>v1</code> is less than or equal to <code>v2</code>.
361 *
362 * @param v1 the left-hand operand.
363 * @param v2 the right-hand operand.
364 * @return a value expression which returns the result of
365 * the comparison when applied. This will be serialized
366 * as the non-public class {@link BinaryRelQueryExp}
367 * with an operation of {@link #LE}.
368 */
369 public static QueryExp leq(ValueExp v1, ValueExp v2)
370 {
371 return new BinaryRelQueryExp(LE, v1, v2);
372 }
373
374 /**
375 * Returns a query expression which evaluates to the result of
376 * comparing <code>v1</code> to <code>v2</code> to see if
377 * <code>v1</code> is less than <code>v2</code>.
378 *
379 * @param v1 the left-hand operand.
380 * @param v2 the right-hand operand.
381 * @return a value expression which returns the result of
382 * the comparison when applied. This will be serialized
383 * as the non-public class {@link BinaryRelQueryExp}
384 * with an operation of {@link #LT}.
385 */
386 public static QueryExp lt(ValueExp v1, ValueExp v2)
387 {
388 return new BinaryRelQueryExp(LT, v1, v2);
389 }
390
391 /**
392 * <p>
393 * Returns a query expression which checks that an
394 * attribute value matches the pattern
395 * specified by the given {@link StringValueExp}.
396 * The pattern uses file-globbing syntax:
397 * </p>
398 * <ul>
399 * <li>'*' stands for any number of arbitrary characters.</li>
400 * <li>'?' stands for a single arbitrary characters.</li>
401 * <li>An expression within '[' and ']' specify a character
402 * class.</li>
403 * <ul>
404 * <li>A range of characters can be specified by separating
405 * the start and end character with '-'.</li>
406 * <li>The complement of the class can be obtained by using
407 * '!' as the first character of the class.</li>
408 * <li>'?', '*' and '[' can occur freely within the class. '-'
409 * may occur as the first or last character. '!' may occur
410 * normally in any position other than the first. ']' may occur
411 * as the first element of the class.</li>
412 * </ul>
413 * <li>'?', '*' and '[' may be escaped using a backslash
414 * character, '\'.</li>
415 * </ul>
416 *
417 * @param attrib the attribute to match.
418 * @param string the substring to find.
419 * @return a query expression representing the result of
420 * matching the pattern against the evaluated
421 * value of the attribute. This will be serialized
422 * as the non-public class {@link MatchQueryExp}.
423 */
424 public static QueryExp match(AttributeValueExp attrib,
425 StringValueExp string)
426 {
427 return new MatchQueryExp(attrib, string.getValue());
428 }
429
430 /**
431 * Returns a value expression which evaluates to the result of
432 * subtracting <code>v2</code> from <code>v1</code>.
433 *
434 * @param v1 the left-hand operand.
435 * @param v2 the right-hand operand.
436 * @return a value expression which returns the result of
437 * the subtraction when applied. This will be serialized
438 * as the non-public class {@link BinaryOpValueExp}
439 * with an operation of {@link #MINUS}.
440 */
441 public static ValueExp minus(ValueExp v1, ValueExp v2)
442 {
443 return new BinaryOpValueExp(MINUS, v1, v2);
444 }
445
446 /**
447 * Returns a query expression representing the negation
448 * of the specified query expression.
449 *
450 * @param q the query to negate.
451 * @return a query expression representing the negation of
452 * <code>q</code>. This will be serialized as the
453 * non-public class {@link NotQueryExp}.
454 */
455 public static QueryExp not(QueryExp q)
456 {
457 return new NotQueryExp(q);
458 }
459
460 /**
461 * Returns a query expression formed from the disjunction
462 * of the two supplied query expressions.
463 *
464 * @param q1 the first query expression.
465 * @param q2 the second query expression.
466 * @return a query expression representing q1 || q2. This
467 * will be serialized as the non-public class
468 * {@link OrQueryExp}.
469 */
470 public static QueryExp or(QueryExp q1, QueryExp q2)
471 {
472 return new OrQueryExp(q1, q2);
473 }
474
475 /**
476 * Returns a value expression which evaluates to the result of
477 * adding <code>v1</code> to <code>v2</code>.
478 *
479 * @param v1 the left-hand operand.
480 * @param v2 the right-hand operand.
481 * @return a value expression which returns the result of
482 * the addition when applied. This will be serialized
483 * as the non-public class {@link BinaryOpValueExp}
484 * with an operation of {@link #PLUS}.
485 */
486 public static ValueExp plus(ValueExp v1, ValueExp v2)
487 {
488 return new BinaryOpValueExp(PLUS, v1, v2);
489 }
490
491 /**
492 * Returns a value expression which evaluates to the result of
493 * multiplying <code>v1</code> by <code>v2</code>.
494 *
495 * @param v1 the left-hand operand.
496 * @param v2 the right-hand operand.
497 * @return a value expression which returns the result of
498 * the multiplication when applied. This will be serialized
499 * as the non-public class {@link BinaryOpValueExp}
500 * with an operation of {@link #TIMES}.
501 */
502 public static ValueExp times(ValueExp v1, ValueExp v2)
503 {
504 return new BinaryOpValueExp(TIMES, v1, v2);
505 }
506
507 /**
508 * Returns a value expression wrapping the specified value.
509 *
510 * @param val the boolean value to wrap.
511 * @return a value expression wrapping <code>val</code>. This
512 * will be serialized as the non-public class
513 * {@link BooleanValueExp}.
514 */
515 public static ValueExp value(boolean val)
516 {
517 return new BooleanValueExp(val);
518 }
519
520 /**
521 * Returns a value expression wrapping the specified value.
522 *
523 * @param val the double value to wrap.
524 * @return a value expression wrapping <code>val</code>. This
525 * will be serialized as the non-public class
526 * {@link NumericValueExp}.
527 */
528 public static ValueExp value(double val)
529 {
530 return new NumericValueExp(val);
531 }
532
533 /**
534 * Returns a value expression wrapping the specified value.
535 *
536 * @param val the float value to wrap.
537 * @return a value expression wrapping <code>val</code>. This
538 * will be serialized as the non-public class
539 * {@link NumericValueExp}.
540 */
541 public static ValueExp value(float val)
542 {
543 return new NumericValueExp(val);
544 }
545
546 /**
547 * Returns a value expression wrapping the specified value.
548 *
549 * @param val the integer value to wrap.
550 * @return a value expression wrapping <code>val</code>. This
551 * will be serialized as the non-public class
552 * {@link NumericValueExp}.
553 */
554 public static ValueExp value(int val)
555 {
556 return new NumericValueExp(val);
557 }
558
559 /**
560 * Returns a value expression wrapping the specified value.
561 *
562 * @param val the long value to wrap.
563 * @return a value expression wrapping <code>val</code>. This
564 * will be serialized as the non-public class
565 * {@link NumericValueExp}.
566 */
567 public static ValueExp value(long val)
568 {
569 return new NumericValueExp(val);
570 }
571
572 /**
573 * Returns a value expression wrapping the specified value.
574 *
575 * @param val the {@link Number} value to wrap.
576 * @return a value expression wrapping <code>val</code>. This
577 * will be serialized as the non-public class
578 * {@link NumericValueExp}.
579 */
580 public static ValueExp value(Number val)
581 {
582 return new NumericValueExp(val);
583 }
584
585 /**
586 * Returns a value expression wrapping the specified string.
587 *
588 * @param val the {@link String} to wrap.
589 * @return a {@link StringValueExp} wrapping <code>val</code>.
590 */
591 public static StringValueExp value(String val)
592 {
593 return new StringValueExp(val);
594 }
595
596 /**
597 * Representation of the conjunction formed using
598 * {@link #and(QueryExp, QueryExp).
599 *
600 * @author Andrew John Hughes (gnu_andrew@member.fsf.org)
601 * @since 1.5
602 */
603 private static final class AndQueryExp
604 extends QueryEval
605 implements QueryExp
606 {
607
608 /**
609 * Compatible with JDK 1.6
610 */
611 private static final long serialVersionUID = -1081892073854801359L;
612
613 /**
614 * The first operand.
615 */
616 private QueryExp exp1;
617
618 /**
619 * The second operand.
620 */
621 private QueryExp exp2;
622
623 /**
624 * Constructs a new {@link AndQueryExp} using
625 * the two specified operands.
626 *
627 * @param exp1 the first query expression.
628 * @param exp2 the second query expression.
629 */
630 public AndQueryExp(QueryExp exp1, QueryExp exp2)
631 {
632 this.exp1 = exp1;
633 this.exp2 = exp2;
634 }
635
636 /**
637 * Returns the conjunction of the two query
638 * expressions.
639 *
640 * @param name the {@link ObjectName} to apply
641 * the query to.
642 * @return the conjunction of applying the name
643 * to both operands.
644 * @throws BadStringOperationException if an invalid string
645 * operation is used by
646 * the query.
647 * @throws BadBinaryOpValueExpException if an invalid expression
648 * is used by the query.
649 * @throws BadAttributeValueExpException if an invalid attribute
650 * is used by the query.
651 * @throws InvalidApplicationException if the query is applied
652 * to the wrong type of bean.
653 */
654 public boolean apply(ObjectName name)
655 throws BadStringOperationException, BadBinaryOpValueExpException,
656 BadAttributeValueExpException, InvalidApplicationException
657 {
658 return exp1.apply(name) && exp2.apply(name);
659 }
660
661 }
662
663 /**
664 * Representation of a query that matches an
665 * attribute's value against a given pattern.
666 *
667 * @author Andrew John Hughes (gnu_andrew@member.fsf.org)
668 * @since 1.5
669 */
670 private static final class MatchQueryExp
671 extends QueryEval
672 implements QueryExp
673 {
674
675 /**
676 * Compatible with JDK 1.6
677 */
678 private static final long serialVersionUID = -7156603696948215014L;
679
680 /**
681 * The attribute to match against.
682 */
683 private AttributeValueExp exp;
684
685 /**
686 * The pattern to be matched.
687 */
688 private String pattern;
689
690 /**
691 * Constructs a new {@link MatchQueryExp} using
692 * the specified attribute value and pattern.
693 *
694 * @param exp the attribute value expression.
695 * @param pattern the pattern.
696 */
697 public MatchQueryExp(AttributeValueExp exp,
698 String pattern)
699 {
700 this.exp = exp;
701 this.pattern = pattern;
702 }
703
704 /**
705 * Returns the result of matching the attribute
706 * value against the pattern.
707 *
708 * @param name the {@link ObjectName} to apply
709 * the query to.
710 * @return the result of the match.
711 * @throws BadStringOperationException if an invalid string
712 * operation is used by
713 * the query.
714 * @throws BadBinaryOpValueExpException if an invalid expression
715 * is used by the query.
716 * @throws BadAttributeValueExpException if an invalid attribute
717 * is used by the query.
718 * @throws InvalidApplicationException if the query is applied
719 * to the wrong type of bean.
720 */
721 public boolean apply(ObjectName name)
722 throws BadStringOperationException, BadBinaryOpValueExpException,
723 BadAttributeValueExpException, InvalidApplicationException
724 {
725 String val = ((StringValueExp) exp.apply(name)).getValue();
726 int valPos = 0;
727 int fallback = -1;
728 int fallbackP = -1;
729 boolean backslash = false;
730 for (int a = 0; a < pattern.length(); ++a)
731 {
732 boolean matched = false;
733 int next = pattern.codePointAt(a);
734 if (!backslash)
735 {
736 if (next == '?' && valPos < val.length())
737 {
738 ++valPos;
739 matched = true;
740 }
741 else if (next == '*')
742 {
743 fallback = valPos;
744 fallbackP = a;
745 matched = true;
746 }
747 else if (next == '[' && valPos < val.length())
748 {
749 boolean negated = false;
750 int b = a + 1;
751 int classChar = pattern.codePointAt(b);
752 do
753 {
754 if (classChar == '!' && b == a + 1)
755 negated = true;
756 else if (pattern.codePointAt(b + 1) == '-' &&
757 pattern.codePointAt(b + 2) != ']')
758 {
759 if (classChar > pattern.codePointAt(b + 2))
760 throw new BadStringOperationException("Invalid range: " +
761 classChar + " to " +
762 pattern.codePointAt(b+2));
763 for (int c = classChar; c <= pattern.codePointAt(b+2); ++c)
764 if (val.codePointAt(valPos) == c)
765 matched = true;
766 b = b + 2;
767 }
768 else if (val.codePointAt(valPos) == classChar)
769 matched = true;
770 ++b;
771 classChar = pattern.codePointAt(b);
772 } while (classChar != ']');
773 if (negated)
774 matched = !matched;
775 ++valPos;
776 a = b;
777 }
778 else if (next == '\\')
779 backslash = true;
780 else if (valPos < val.length() && next == val.codePointAt(valPos))
781 {
782 matched = true;
783 ++valPos;
784 }
785 }
786 else
787 {
788 backslash = false;
789 if (valPos < val.length() && next == val.codePointAt(valPos))
790 {
791 matched = true;
792 ++valPos;
793 }
794 }
795 if (!matched)
796 if (fallback != -1)
797 {
798 ++fallback;
799 valPos = fallback;
800 a = fallbackP;
801 if (valPos == val.length())
802 return false;
803 continue;
804 }
805 else
806 return false;
807 }
808 return true;
809 }
810 }
811
812 /**
813 * Representation of the retrieval of an attribute
814 * value from a certain class for {@link #attr(String,String)}.
815 *
816 * @author Andrew John Hughes (gnu_andrew@member.fsf.org)
817 * @since 1.5
818 */
819 private static final class QualifiedAttributeValueExp
820 extends AttributeValueExp
821 {
822
823 /**
824 * Compatible with JDK 1.6
825 */
826 private static final long serialVersionUID = 8832517277410933254L;
827
828 /**
829 * The name of the class from which the attribute is taken.
830 */
831 private String className;
832
833 /**
834 * Constructs a new {@link QualifiedAttributeValueExp} using
835 * the specified class name and attribute name.
836 *
837 * @param className the class name.
838 * @param name the attribute name.
839 */
840 public QualifiedAttributeValueExp(String className, String name)
841 {
842 super(name);
843 this.className = className;
844 }
845
846 /**
847 * Applies the {@link AttributeValueExp} to the specified
848 * management bean by checking that the attribute will be
849 * obtained from the correct class (by a class to
850 * {@link MBeanServer#getObjectInstance(ObjectName)} and
851 * then obtaining the attribute value from the
852 * {@link MBeanServer}, using it to create a
853 * {@link StringValueExp}.
854 *
855 * @param name the {@link ObjectName} of the bean to obtain
856 * the value from.
857 * @return a {@link StringValueExp} containing the result.
858 * @throws BadStringOperationException if an invalid string
859 * operation is used by
860 * the value expression.
861 * @throws BadBinaryOpValueExpException if an invalid expression
862 * is used by the value expression.
863 * @throws BadAttributeValueExpException if an invalid attribute
864 * is used by the value expression.
865 * @throws InvalidApplicationException if the value expression is applied
866 * to the wrong type of bean.
867 */
868 public ValueExp apply(ObjectName name)
869 throws BadStringOperationException, BadBinaryOpValueExpException,
870 BadAttributeValueExpException, InvalidApplicationException
871 {
872 try
873 {
874 if (!(QueryEval.getMBeanServer().getObjectInstance(name).getClassName().equals(className)))
875 throw new BadAttributeValueExpException("The value is not from " +
876 "the correct class.");
877 }
878 catch (InstanceNotFoundException e)
879 {
880 throw (BadAttributeValueExpException)
881 new BadAttributeValueExpException("The named bean is not registered.").initCause(e);
882 }
883 return super.apply(name);
884 }
885
886 }
887
888 /**
889 * Representation of the comparison of a value with
890 * a pair of bounds formed using
891 * {@link #between(ValueExp, ValueExp, ValueExp).
892 *
893 * @author Andrew John Hughes (gnu_andrew@member.fsf.org)
894 * @since 1.5
895 */
896 private static final class BetweenQueryExp
897 extends QueryEval
898 implements QueryExp
899 {
900
901 /**
902 * Compatible with JDK 1.6
903 */
904 private static final long serialVersionUID = -2933597532866307444L;
905
906 /**
907 * The value to compare.
908 */
909 private ValueExp exp1;
910
911 /**
912 * The lower boundary.
913 */
914 private ValueExp exp2;
915
916 /**
917 * The upper boundary.
918 */
919 private ValueExp exp3;
920
921 /**
922 * Constructs a new {@link BetweenQueryExp} using
923 * the specified comparison value and the given
924 * bounds.
925 *
926 * @param exp1 the value to compare.
927 * @param exp2 the lower bound.
928 * @param exp3 the upper bound.
929 */
930 public BetweenQueryExp(ValueExp exp1, ValueExp exp2,
931 ValueExp exp3)
932 {
933 this.exp1 = exp1;
934 this.exp2 = exp2;
935 this.exp3 = exp3;
936 }
937
938 /**
939 * Returns the result of the comparison between
940 * the value and the two bounds.
941 *
942 * @param name the {@link ObjectName} to apply
943 * the query to.
944 * @return the result of the comparison.
945 * @throws BadStringOperationException if an invalid string
946 * operation is used by
947 * the query.
948 * @throws BadBinaryOpValueExpException if an invalid expression
949 * is used by the query.
950 * @throws BadAttributeValueExpException if an invalid attribute
951 * is used by the query.
952 * @throws InvalidApplicationException if the query is applied
953 * to the wrong type of bean.
954 */
955 public boolean apply(ObjectName name)
956 throws BadStringOperationException, BadBinaryOpValueExpException,
957 BadAttributeValueExpException, InvalidApplicationException
958 {
959 String v1 = exp1.apply(name).toString();
960 String v2 = exp2.apply(name).toString();
961 String v3 = exp3.apply(name).toString();
962 return v1.compareTo(v2) >= 0 && v1.compareTo(v3) <= 0;
963 }
964
965 }
966
967 /**
968 * Representation of the retrieval of the name of
969 * a bean's class for {@link #classattr()}.
970 *
971 * @author Andrew John Hughes (gnu_andrew@member.fsf.org)
972 * @since 1.5
973 */
974 private static final class ClassAttributeValueExp
975 extends AttributeValueExp
976 {
977
978 /**
979 * Compatible with JDK 1.6
980 */
981 private static final long serialVersionUID = -1081892073854801359L;
982
983 /**
984 * Obtains the name of the specified bean's class using a call
985 * to {@link MBeanServer#getObjectInstance(ObjectName)}.
986 *
987 * @param name the {@link ObjectName} of the bean to obtain
988 * the class name from.
989 * @return a {@link StringValueExp} containing the result.
990 * @throws BadStringOperationException if an invalid string
991 * operation is used by
992 * the value expression.
993 * @throws BadBinaryOpValueExpException if an invalid expression
994 * is used by the value expression.
995 * @throws BadAttributeValueExpException if an invalid attribute
996 * is used by the value expression.
997 * @throws InvalidApplicationException if the value expression is applied
998 * to the wrong type of bean.
999 */
1000 public ValueExp apply(ObjectName name)
1001 throws BadStringOperationException, BadBinaryOpValueExpException,
1002 BadAttributeValueExpException, InvalidApplicationException
1003 {
1004 try
1005 {
1006 return new StringValueExp(QueryEval.getMBeanServer().getObjectInstance(name).getClassName());
1007 }
1008 catch (InstanceNotFoundException e)
1009 {
1010 throw (BadAttributeValueExpException)
1011 new BadAttributeValueExpException("The named bean is not registered.").initCause(e);
1012 }
1013 }
1014
1015 }
1016
1017 /**
1018 * Representation of a binary operation formed using
1019 * {@link #div(ValueExp, ValueExp), {@link #plus(ValueExp,ValueExp)},
1020 * {@link #minus(ValueExp, ValueExp) or
1021 * {@link #times(ValueExp, ValueExp)}.
1022 *
1023 * @author Andrew John Hughes (gnu_andrew@member.fsf.org)
1024 * @since 1.5
1025 */
1026 private static final class BinaryOpValueExp
1027 extends QueryEval
1028 implements ValueExp
1029 {
1030
1031 /**
1032 * Compatible with JDK 1.6
1033 */
1034 private static final long serialVersionUID = 1216286847881456786L;
1035
1036 /**
1037 * The operation to perform.
1038 */
1039 private int op;
1040
1041 /**
1042 * The left-hand operand.
1043 */
1044 private ValueExp exp1;
1045
1046 /**
1047 * The right-hand operand.
1048 */
1049 private ValueExp exp2;
1050
1051 /**
1052 * Constructs a new {@link BinaryOpValueExp} using
1053 * the specified operation and the two values supplied.
1054 *
1055 * @param op the operation to perform.
1056 * @param exp1 the left-hand operand.
1057 * @param exp2 the right-hand operand.
1058 */
1059 public BinaryOpValueExp(int op, ValueExp exp1, ValueExp exp2)
1060 {
1061 this.op = op;
1062 this.exp1 = exp1;
1063 this.exp2 = exp2;
1064 }
1065
1066 /**
1067 * Returns the result of performing the operation on
1068 * <code>exp1</code> and <code>exp2</code>.
1069 *
1070 * @param name the {@link ObjectName} to apply
1071 * the query to.
1072 * @return the result of the operation.
1073 * @throws BadStringOperationException if an invalid string
1074 * operation is used by
1075 * the query.
1076 * @throws BadBinaryOpValueExpException if an invalid expression
1077 * is used by the query.
1078 * @throws BadAttributeValueExpException if an invalid attribute
1079 * is used by the query.
1080 * @throws InvalidApplicationException if the query is applied
1081 * to the wrong type of bean.
1082 */
1083 public ValueExp apply(ObjectName name)
1084 throws BadStringOperationException, BadBinaryOpValueExpException,
1085 BadAttributeValueExpException, InvalidApplicationException
1086 {
1087 NumericValueExp v1 = (NumericValueExp) exp1.apply(name);
1088 NumericValueExp v2 = (NumericValueExp) exp2.apply(name);
1089 switch (op)
1090 {
1091 case PLUS:
1092 return v1.plus(v2);
1093 case MINUS:
1094 return v1.minus(v2);
1095 case TIMES:
1096 return v1.times(v2);
1097 case DIV:
1098 return v1.div(v2);
1099 default:
1100 throw new BadBinaryOpValueExpException(this);
1101 }
1102 }
1103
1104 /**
1105 * Returns a textual representation of the operation.
1106 *
1107 * @return a textual version of the operation.
1108 */
1109 public String toString()
1110 {
1111 String opS;
1112 switch (op)
1113 {
1114 case PLUS:
1115 opS = "+";
1116 break;
1117 case MINUS:
1118 opS = "-";
1119 break;
1120 case TIMES:
1121 opS = "x";
1122 break;
1123 case DIV:
1124 opS = "/";
1125 break;
1126 default:
1127 opS = "?";
1128 }
1129 return exp1 + " " + opS + " " + exp2;
1130 }
1131 }
1132
1133 /**
1134 * Representation of a binary operation formed using
1135 * {@link #eq(ValueExp, ValueExp), {@link #geq(ValueExp, ValueExp)},
1136 * {@link #leq(ValueExp, ValueExp), {@link #gt(ValueExp, ValueExp)}
1137 * or {@link #lt(ValueExp, ValueExp)}.
1138 *
1139 * @author Andrew John Hughes (gnu_andrew@member.fsf.org)
1140 * @since 1.5
1141 */
1142 private static final class BinaryRelQueryExp
1143 extends QueryEval
1144 implements QueryExp
1145 {
1146
1147 /**
1148 * Compatible with JDK 1.6
1149 */
1150 private static final long serialVersionUID = -5690656271650491000L;
1151
1152 /**
1153 * The operation to perform.
1154 */
1155 private int relOp;
1156
1157 /**
1158 * The left-hand operand.
1159 */
1160 private ValueExp exp1;
1161
1162 /**
1163 * The right-hand operand.
1164 */
1165 private ValueExp exp2;
1166
1167 /**
1168 * Constructs a new {@link BinaryRelQueryExp} using
1169 * the specified operation and the two values supplied.
1170 *
1171 * @param relOp the operation to perform.
1172 * @param exp1 the left-hand operand.
1173 * @param exp2 the right-hand operand.
1174 */
1175 public BinaryRelQueryExp(int relOp, ValueExp exp1, ValueExp exp2)
1176 {
1177 this.relOp = relOp;
1178 this.exp1 = exp1;
1179 this.exp2 = exp2;
1180 }
1181
1182 /**
1183 * Returns the result of performing the operation on
1184 * <code>exp1</code> and <code>exp2</code>.
1185 *
1186 * @param name the {@link ObjectName} to apply
1187 * the query to.
1188 * @return the result of the comparison.
1189 * @throws BadStringOperationException if an invalid string
1190 * operation is used by
1191 * the query.
1192 * @throws BadBinaryOpValueExpException if an invalid expression
1193 * is used by the query.
1194 * @throws BadAttributeValueExpException if an invalid attribute
1195 * is used by the query.
1196 * @throws InvalidApplicationException if the query is applied
1197 * to the wrong type of bean.
1198 */
1199 public boolean apply(ObjectName name)
1200 throws BadStringOperationException, BadBinaryOpValueExpException,
1201 BadAttributeValueExpException, InvalidApplicationException
1202 {
1203 String v1 = exp1.apply(name).toString();
1204 String v2 = exp2.apply(name).toString();
1205 switch (relOp)
1206 {
1207 case EQ:
1208 return v1.equals(v2);
1209 case GT:
1210 return v1.compareTo(v2) > 0;
1211 case GE:
1212 return v1.compareTo(v2) >= 0;
1213 case LE:
1214 return v1.compareTo(v2) <= 0;
1215 case LT:
1216 return v1.compareTo(v2) < 0;
1217 default:
1218 throw new BadStringOperationException("Invalid operator: " + relOp);
1219 }
1220 }
1221
1222 /**
1223 * Returns a textual representation of the operation.
1224 *
1225 * @return a textual version of the operation.
1226 */
1227 public String toString()
1228 {
1229 String op;
1230 switch (relOp)
1231 {
1232 case EQ:
1233 op = "=";
1234 break;
1235 case GT:
1236 op = ">";
1237 break;
1238 case GE:
1239 op = ">=";
1240 break;
1241 case LE:
1242 op = "<=";
1243 break;
1244 case LT:
1245 op = "<";
1246 break;
1247 default:
1248 op = "?";
1249 }
1250 return exp1 + " " + op + " " + exp2;
1251 }
1252 }
1253
1254 /**
1255 * Representation of the comparison of a value with
1256 * the members of a list formed using
1257 * {@link #in(ValueExp, ValueExp[]).
1258 *
1259 * @author Andrew John Hughes (gnu_andrew@member.fsf.org)
1260 * @since 1.5
1261 */
1262 private static final class InQueryExp
1263 extends QueryEval
1264 implements QueryExp
1265 {
1266
1267 /**
1268 * Compatible with JDK 1.6
1269 */
1270 private static final long serialVersionUID = -5801329450358952434L;
1271
1272 /**
1273 * The value to look for.
1274 */
1275 private ValueExp val;
1276
1277 /**
1278 * The array to search.
1279 */
1280 private ValueExp[] valueList;
1281
1282 /**
1283 * Constructs a new {@link InQueryExp} using
1284 * the specified comparison value and the given
1285 * list.
1286 *
1287 * @param val the value to compare.
1288 * @param valueList the list of values.
1289 */
1290 public InQueryExp(ValueExp val, ValueExp[] valueList)
1291 {
1292 this.val = val;
1293 this.valueList = valueList;
1294 }
1295
1296 /**
1297 * Returns the result of the comparison between
1298 * the value and the list of allowed values.
1299 *
1300 * @param name the {@link ObjectName} to apply
1301 * the query to.
1302 * @return the result of the comparison.
1303 * @throws BadStringOperationException if an invalid string
1304 * operation is used by
1305 * the query.
1306 * @throws BadBinaryOpValueExpException if an invalid expression
1307 * is used by the query.
1308 * @throws BadAttributeValueExpException if an invalid attribute
1309 * is used by the query.
1310 * @throws InvalidApplicationException if the query is applied
1311 * to the wrong type of bean.
1312 */
1313 public boolean apply(ObjectName name)
1314 throws BadStringOperationException, BadBinaryOpValueExpException,
1315 BadAttributeValueExpException, InvalidApplicationException
1316 {
1317 String v = val.apply(name).toString();
1318 for (ValueExp vl : valueList)
1319 if (v.equals(vl.apply(name).toString()))
1320 return true;
1321 return false;
1322 }
1323
1324 }
1325
1326 /**
1327 * Representation of the inheritance check on a
1328 * bean for {@link #isInstanceOf(StringValueExp)}.
1329 *
1330 * @author Andrew John Hughes (gnu_andrew@member.fsf.org)
1331 * @since 1.6
1332 */
1333 private static final class InstanceOfQueryExp
1334 extends QueryEval
1335 implements QueryExp
1336 {
1337
1338 /**
1339 * Compatible with JDK 1.6
1340 */
1341 private static final long serialVersionUID = -1081892073854801359L;
1342
1343 /**
1344 * The name of the class from which the attribute is taken.
1345 */
1346 private StringValueExp classNameValue;
1347
1348 /**
1349 * Constructs a new {@link InstanceOfQueryExp} using
1350 * the specified class name.
1351 *
1352 * @param classNameValue the class name.
1353 */
1354 public InstanceOfQueryExp(StringValueExp classNameValue)
1355 {
1356 this.classNameValue = classNameValue;
1357 }
1358
1359 /**
1360 * Checks that the bean specified by the supplied
1361 * {@link ObjectName} is of the correct class
1362 * using {@link MBeanServer#isInstanceOf(ObjectName,String)}.
1363 * where the string is obtained by evaluating
1364 * <code>classNameValue</code>.
1365 *
1366 * @param name the {@link ObjectName} of the bean to obtain
1367 * the value from.
1368 * @return true if the bean is an instance of the class.
1369 * @throws BadStringOperationException if an invalid string
1370 * operation is used by
1371 * the value expression.
1372 * @throws BadBinaryOpValueExpException if an invalid expression
1373 * is used by the value expression.
1374 * @throws BadAttributeValueExpException if an invalid attribute
1375 * is used by the value expression.
1376 * @throws InvalidApplicationException if the value expression is applied
1377 * to the wrong type of bean.
1378 */
1379 public boolean apply(ObjectName name)
1380 throws BadStringOperationException, BadBinaryOpValueExpException,
1381 BadAttributeValueExpException, InvalidApplicationException
1382 {
1383 try
1384 {
1385 String className = ((StringValueExp)
1386 classNameValue.apply(name)).getValue();
1387 return QueryEval.getMBeanServer().isInstanceOf(name, className);
1388 }
1389 catch (InstanceNotFoundException e)
1390 {
1391 throw (BadAttributeValueExpException)
1392 new BadAttributeValueExpException("The named bean is not registered.").initCause(e);
1393 }
1394 }
1395
1396 }
1397
1398 /**
1399 * Representation of the negation of a query formed using
1400 * {@link #not(QueryExp).
1401 *
1402 * @author Andrew John Hughes (gnu_andrew@member.fsf.org)
1403 * @since 1.5
1404 */
1405 private static final class NotQueryExp
1406 extends QueryEval
1407 implements QueryExp
1408 {
1409
1410 /**
1411 * Compatible with JDK 1.6
1412 */
1413 private static final long serialVersionUID = 5269643775896723397L;
1414
1415 /**
1416 * The expression to negate.
1417 */
1418 private QueryExp exp;
1419
1420 /**
1421 * Constructs a new {@link NotQueryExp} using
1422 * the specified query expression.
1423 *
1424 * @param exp the expression to negate.
1425 */
1426 public NotQueryExp(QueryExp exp)
1427 {
1428 this.exp = exp;
1429 }
1430
1431 /**
1432 * Returns the result of the negation.
1433 *
1434 * @param name the {@link ObjectName} to apply
1435 * the query to.
1436 * @return the result of the negation.
1437 * @throws BadStringOperationException if an invalid string
1438 * operation is used by
1439 * the query.
1440 * @throws BadBinaryOpValueExpException if an invalid expression
1441 * is used by the query.
1442 * @throws BadAttributeValueExpException if an invalid attribute
1443 * is used by the query.
1444 * @throws InvalidApplicationException if the query is applied
1445 * to the wrong type of bean.
1446 */
1447 public boolean apply(ObjectName name)
1448 throws BadStringOperationException, BadBinaryOpValueExpException,
1449 BadAttributeValueExpException, InvalidApplicationException
1450 {
1451 return !(exp.apply(name));
1452 }
1453
1454 }
1455
1456 /**
1457 * Representation of the disjunction formed using
1458 * {@link #or(QueryExp, QueryExp).
1459 *
1460 * @author Andrew John Hughes (gnu_andrew@member.fsf.org)
1461 * @since 1.5
1462 */
1463 private static final class OrQueryExp
1464 extends QueryEval
1465 implements QueryExp
1466 {
1467
1468 /**
1469 * Compatible with JDK 1.6
1470 */
1471 private static final long serialVersionUID = 2962973084421716523L;
1472
1473 /**
1474 * The first operand.
1475 */
1476 private QueryExp exp1;
1477
1478 /**
1479 * The second operand.
1480 */
1481 private QueryExp exp2;
1482
1483 /**
1484 * Constructs a new {@link OrQueryExp} using
1485 * the two specified operands.
1486 *
1487 * @param exp1 the first query expression.
1488 * @param exp2 the second query expression.
1489 */
1490 public OrQueryExp(QueryExp exp1, QueryExp exp2)
1491 {
1492 this.exp1 = exp1;
1493 this.exp2 = exp2;
1494 }
1495
1496 /**
1497 * Returns the disjunction of the two query
1498 * expressions.
1499 *
1500 * @param name the {@link ObjectName} to apply
1501 * the query to.
1502 * @return the disjunction of applying the name
1503 * to both operands.
1504 * @throws BadStringOperationException if an invalid string
1505 * operation is used by
1506 * the query.
1507 * @throws BadBinaryOpValueExpException if an invalid expression
1508 * is used by the query.
1509 * @throws BadAttributeValueExpException if an invalid attribute
1510 * is used by the query.
1511 * @throws InvalidApplicationException if the query is applied
1512 * to the wrong type of bean.
1513 */
1514 public boolean apply(ObjectName name)
1515 throws BadStringOperationException, BadBinaryOpValueExpException,
1516 BadAttributeValueExpException, InvalidApplicationException
1517 {
1518 return exp1.apply(name) || exp2.apply(name);
1519 }
1520
1521 }
1522
1523 /**
1524 * Representation of a boolean being used as an argument
1525 * to a relational constraint, formed using
1526 * {@link #value(boolean)}.
1527 *
1528 * @author Andrew John Hughes (gnu_andrew@member.fsf.org)
1529 * @since 1.5
1530 */
1531 private static final class BooleanValueExp
1532 extends QueryEval
1533 implements ValueExp
1534 {
1535
1536 /**
1537 * Compatible with JDK 1.6
1538 */
1539 private static final long serialVersionUID = 7754922052666594581L;
1540
1541 /**
1542 * The boolean value.
1543 */
1544 private boolean val;
1545
1546 /**
1547 * Constructs a new {@link BooleanValueExp} using the
1548 * specified value.
1549 *
1550 * @param val the boolean value used for this expression.
1551 */
1552 public BooleanValueExp(boolean val)
1553 {
1554 this.val = val;
1555 }
1556
1557 /**
1558 * Applies the {@link BooleanValueExp} to the specified
1559 * management bean by simply returning the value.
1560 *
1561 * @param name the {@link ObjectName} of the bean.
1562 * @return the {@link BooleanValueExp} itself.
1563 * @throws BadStringOperationException if an invalid string
1564 * operation is used by
1565 * the value expression.
1566 * @throws BadBinaryOpValueExpException if an invalid expression
1567 * is used by the value expression.
1568 * @throws BadAttributeValueExpException if an invalid attribute
1569 * is used by the value expression.
1570 * @throws InvalidApplicationException if the value expression is applied
1571 * to the wrong type of bean.
1572 */
1573 public ValueExp apply(ObjectName name)
1574 throws BadStringOperationException, BadBinaryOpValueExpException,
1575 BadAttributeValueExpException, InvalidApplicationException
1576 {
1577 return this;
1578 }
1579
1580 /**
1581 * Returns the value as a string.
1582 *
1583 * @return the value in textual form.
1584 */
1585 public String toString()
1586 {
1587 return Boolean.toString(val);
1588 }
1589
1590 }
1591
1592 /**
1593 * Representation of a number being used as an argument
1594 * to a relational constraint, formed using
1595 * {@link #value(double)}, {@link #value(float)},
1596 * {@link #value(int)}, {@link #value(long)} or
1597 * {@link #value(Number)}.
1598 *
1599 * @author Andrew John Hughes (gnu_andrew@member.fsf.org)
1600 * @since 1.5
1601 */
1602 private static final class NumericValueExp
1603 extends QueryEval
1604 implements ValueExp
1605 {
1606
1607 /**
1608 * Compatible with JDK 1.6
1609 */
1610 private static final long serialVersionUID = -4679739485102359104L;
1611
1612 /**
1613 * The numeric value.
1614 */
1615 private Number val;
1616
1617 /**
1618 * Constructs a new {@link NumericValueExp} using the
1619 * specified value.
1620 *
1621 * @param val the numeric value used for this expression.
1622 */
1623 public NumericValueExp(Number val)
1624 {
1625 this.val = val;
1626 }
1627
1628 /**
1629 * Applies the {@link NumericValueExp} to the specified
1630 * management bean by simply returning the value.
1631 *
1632 * @param name the {@link ObjectName} of the bean.
1633 * @return the {@link NumericValueExp} itself.
1634 * @throws BadStringOperationException if an invalid string
1635 * operation is used by
1636 * the value expression.
1637 * @throws BadBinaryOpValueExpException if an invalid expression
1638 * is used by the value expression.
1639 * @throws BadAttributeValueExpException if an invalid attribute
1640 * is used by the value expression.
1641 * @throws InvalidApplicationException if the value expression is applied
1642 * to the wrong type of bean.
1643 */
1644 public ValueExp apply(ObjectName name)
1645 throws BadStringOperationException, BadBinaryOpValueExpException,
1646 BadAttributeValueExpException, InvalidApplicationException
1647 {
1648 return this;
1649 }
1650
1651 /**
1652 * Returns the value.
1653 */
1654 public Number getValue()
1655 {
1656 return val;
1657 }
1658
1659 /**
1660 * Returns the value as a string.
1661 *
1662 * @return the value in textual form.
1663 */
1664 public String toString()
1665 {
1666 return val.toString();
1667 }
1668
1669 /**
1670 * Return the result of adding the specified
1671 * {@link NumericValueExp} to this one.
1672 *
1673 * @param o the value to add.
1674 * @return the result of the addition.
1675 */
1676 public NumericValueExp plus(NumericValueExp o)
1677 {
1678 Number v = o.getValue();
1679 if (val instanceof Double)
1680 {
1681 double d = val.doubleValue();
1682 if (v instanceof Double)
1683 return new NumericValueExp(d + v.doubleValue());
1684 else if (v instanceof Float)
1685 return new NumericValueExp(d + v.floatValue());
1686 else if (v instanceof Long)
1687 return new NumericValueExp(d + v.longValue());
1688 else
1689 return new NumericValueExp(d + v.intValue());
1690 }
1691 else if (val instanceof Float)
1692 {
1693 float f = val.floatValue();
1694 if (v instanceof Double)
1695 return new NumericValueExp(f + v.doubleValue());
1696 else if (v instanceof Float)
1697 return new NumericValueExp(f + v.floatValue());
1698 else if (v instanceof Long)
1699 return new NumericValueExp(f + v.longValue());
1700 else
1701 return new NumericValueExp(f + v.intValue());
1702 }
1703 else if (val instanceof Long)
1704 {
1705 long l = val.longValue();
1706 if (v instanceof Double)
1707 return new NumericValueExp(l + v.doubleValue());
1708 else if (v instanceof Float)
1709 return new NumericValueExp(l + v.floatValue());
1710 else if (v instanceof Long)
1711 return new NumericValueExp(l + v.longValue());
1712 else
1713 return new NumericValueExp(l + v.intValue());
1714 }
1715 int i = val.intValue();
1716 if (v instanceof Double)
1717 return new NumericValueExp(i + v.doubleValue());
1718 else if (v instanceof Float)
1719 return new NumericValueExp(i + v.floatValue());
1720 else if (v instanceof Long)
1721 return new NumericValueExp(i + v.longValue());
1722 else
1723 return new NumericValueExp(i + v.intValue());
1724 }
1725
1726 /**
1727 * Return New NumericValueExp(the result of subtracting the specified
1728 * {@link NumericValueExp} from this one.
1729 *
1730 * @param o the value to subtract.
1731 * @return new NumericValueExp(the result of the subtraction.
1732 */
1733 public NumericValueExp minus(NumericValueExp o)
1734 {
1735 Number v = o.getValue();
1736 if (val instanceof Double)
1737 {
1738 double d = val.doubleValue();
1739 if (v instanceof Double)
1740 return new NumericValueExp(d - v.doubleValue());
1741 else if (v instanceof Float)
1742 return new NumericValueExp(d - v.floatValue());
1743 else if (v instanceof Long)
1744 return new NumericValueExp(d - v.longValue());
1745 else
1746 return new NumericValueExp(d - v.intValue());
1747 }
1748 else if (val instanceof Float)
1749 {
1750 float f = val.floatValue();
1751 if (v instanceof Double)
1752 return new NumericValueExp(f - v.doubleValue());
1753 else if (v instanceof Float)
1754 return new NumericValueExp(f - v.floatValue());
1755 else if (v instanceof Long)
1756 return new NumericValueExp(f - v.longValue());
1757 else
1758 return new NumericValueExp(f - v.intValue());
1759 }
1760 else if (val instanceof Long)
1761 {
1762 long l = val.longValue();
1763 if (v instanceof Double)
1764 return new NumericValueExp(l - v.doubleValue());
1765 else if (v instanceof Float)
1766 return new NumericValueExp(l - v.floatValue());
1767 else if (v instanceof Long)
1768 return new NumericValueExp(l - v.longValue());
1769 else
1770 return new NumericValueExp(l - v.intValue());
1771 }
1772 int i = val.intValue();
1773 if (v instanceof Double)
1774 return new NumericValueExp(i - v.doubleValue());
1775 else if (v instanceof Float)
1776 return new NumericValueExp(i - v.floatValue());
1777 else if (v instanceof Long)
1778 return new NumericValueExp(i - v.longValue());
1779 else
1780 return new NumericValueExp(i - v.intValue());
1781 }
1782
1783 /**
1784 * Return New NumericValueExp(the result of multiplying the specified
1785 * {@link NumericValueExp} to this one.
1786 *
1787 * @param o the value to multiply by.
1788 * @return new NumericValueExp(the result of the multiplication.
1789 */
1790 public NumericValueExp times(NumericValueExp o)
1791 {
1792 Number v = o.getValue();
1793 if (val instanceof Double)
1794 {
1795 double d = val.doubleValue();
1796 if (v instanceof Double)
1797 return new NumericValueExp(d * v.doubleValue());
1798 else if (v instanceof Float)
1799 return new NumericValueExp(d * v.floatValue());
1800 else if (v instanceof Long)
1801 return new NumericValueExp(d * v.longValue());
1802 else
1803 return new NumericValueExp(d * v.intValue());
1804 }
1805 else if (val instanceof Float)
1806 {
1807 float f = val.floatValue();
1808 if (v instanceof Double)
1809 return new NumericValueExp(f * v.doubleValue());
1810 else if (v instanceof Float)
1811 return new NumericValueExp(f * v.floatValue());
1812 else if (v instanceof Long)
1813 return new NumericValueExp(f * v.longValue());
1814 else
1815 return new NumericValueExp(f * v.intValue());
1816 }
1817 else if (val instanceof Long)
1818 {
1819 long l = val.longValue();
1820 if (v instanceof Double)
1821 return new NumericValueExp(l * v.doubleValue());
1822 else if (v instanceof Float)
1823 return new NumericValueExp(l * v.floatValue());
1824 else if (v instanceof Long)
1825 return new NumericValueExp(l * v.longValue());
1826 else
1827 return new NumericValueExp(l * v.intValue());
1828 }
1829 int i = val.intValue();
1830 if (v instanceof Double)
1831 return new NumericValueExp(i * v.doubleValue());
1832 else if (v instanceof Float)
1833 return new NumericValueExp(i * v.floatValue());
1834 else if (v instanceof Long)
1835 return new NumericValueExp(i * v.longValue());
1836 else
1837 return new NumericValueExp(i * v.intValue());
1838 }
1839
1840 /**
1841 * Return New NumericValueExp(the result of dividing this
1842 * number by value of the specified
1843 * {@link NumericValueExp}.
1844 *
1845 * @param o the value to divide by.
1846 * @return new NumericValueExp(the result of the division.
1847 */
1848 public NumericValueExp div(NumericValueExp o)
1849 {
1850 Number v = o.getValue();
1851 if (val instanceof Double)
1852 {
1853 double d = val.doubleValue();
1854 if (v instanceof Double)
1855 return new NumericValueExp(d / v.doubleValue());
1856 else if (v instanceof Float)
1857 return new NumericValueExp(d / v.floatValue());
1858 else if (v instanceof Long)
1859 return new NumericValueExp(d / v.longValue());
1860 else
1861 return new NumericValueExp(d / v.intValue());
1862 }
1863 else if (val instanceof Float)
1864 {
1865 float f = val.floatValue();
1866 if (v instanceof Double)
1867 return new NumericValueExp(f / v.doubleValue());
1868 else if (v instanceof Float)
1869 return new NumericValueExp(f / v.floatValue());
1870 else if (v instanceof Long)
1871 return new NumericValueExp(f / v.longValue());
1872 else
1873 return new NumericValueExp(f / v.intValue());
1874 }
1875 else if (val instanceof Long)
1876 {
1877 long l = val.longValue();
1878 if (v instanceof Double)
1879 return new NumericValueExp(l / v.doubleValue());
1880 else if (v instanceof Float)
1881 return new NumericValueExp(l / v.floatValue());
1882 else if (v instanceof Long)
1883 return new NumericValueExp(l / v.longValue());
1884 else
1885 return new NumericValueExp(l / v.intValue());
1886 }
1887 int i = val.intValue();
1888 if (v instanceof Double)
1889 return new NumericValueExp(i / v.doubleValue());
1890 else if (v instanceof Float)
1891 return new NumericValueExp(i / v.floatValue());
1892 else if (v instanceof Long)
1893 return new NumericValueExp(i / v.longValue());
1894 else
1895 return new NumericValueExp(i / v.intValue());
1896 }
1897
1898 }
1899
1900 }