Subversion Repositories openrisc

/* Query.java -- Static methods for query construction.
   Copyright (C) 2007 Free Software Foundation, Inc.
 
This file is part of GNU Classpath.
 
GNU Classpath is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.
 
GNU Classpath is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
General Public License for more details.
 
You should have received a copy of the GNU General Public License
along with GNU Classpath; see the file COPYING.  If not, write to the
Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
02110-1301 USA.
 
Linking this library statically or dynamically with other modules is
making a combined work based on this library.  Thus, the terms and
conditions of the GNU General Public License cover the whole
combination.
 
As a special exception, the copyright holders of this library give you
permission to link this library with independent modules to produce an
executable, regardless of the license terms of these independent
modules, and to copy and distribute the resulting executable under
terms of your choice, provided that you also meet, for each linked
independent module, the terms and conditions of the license of that
module.  An independent module is a module which is not derived from
or based on this library.  If you modify this library, you may extend
this exception to your version of the library, but you are not
obligated to do so.  If you do not wish to do so, delete this
exception statement from your version. */
 
package javax.management;
 
/**
 * Provides static methods for constructing queries.  Queries
 * may be used to list and enumerate management beans, via
 * the {@link MBeanServer}.  By using the methods in this class,
 * complex queries can be created from their more basic
 * components.
 *
 * @author Andrew John Hughes (gnu_andrew@member.fsf.org)
 * @since 1.5
 */
public class Query
{
 
  /**
   * A code representing the {@link #plus(ValueExp, ValueExp)
   * query to be used in serialization.
   */
  public static final int PLUS = 0;
 
  /**
   * A code representing the {@link #minus(ValueExp, ValueExp)
   * query to be used in serialization.
   */
  public static final int MINUS = 1;
 
  /**
   * A code representing the {@link #times(ValueExp, ValueExp)
   * query to be used in serialization.
   */
  public static final int TIMES = 2;
 
  /**
   * A code representing the {@link #div(ValueExp, ValueExp)
   * query to be used in serialization.
   */
  public static final int DIV = 3;
 
  /**
   * A code representing the {@link #gt(ValueExp, ValueExp)
   * query to be used in serialization.
   */
  public static final int GT = 0;
 
  /**
   * A code representing the {@link #lt(ValueExp, ValueExp)
   * query to be used in serialization.
   */
  public static final int LT = 1;
 
  /**
   * A code representing the {@link #ge(ValueExp, ValueExp)
   * query to be used in serialization.
   */
  public static final int GE = 2;
 
  /**
   * A code representing the {@link #le(ValueExp, ValueExp)
   * query to be used in serialization.
   */
  public static final int LE = 3;
 
  /**
   * A code representing the {@link #eq(ValueExp, ValueExp)
   * query to be used in serialization.
   */
  public static final int EQ = 4;
 
  /**
   * Returns a query expression formed from the conjunction
   * of the two supplied query expressions.
   *
   * @param q1 the first query expression.
   * @param q2 the second query expression.
   * @return a query expression representing q1 && q2.  This
   *         will be serialized as the non-public class
   *         {@link AndQueryExp}.
   */
  public static QueryExp and(QueryExp q1, QueryExp q2)
  {
    return new AndQueryExp(q1, q2);
  }
 
  /**
   * Returns a query expression which checks that an
   * attribute value held by the specified
   * {@link AttributeValueExp} contains the string
   * specified by the given {@link StringValueExp}.
   *
   * @param attrib the attribute to match.
   * @param string the substring to find.
   * @return a query expression representing
   *         <code>attrib.matches("*" + string + "*")</code>.
   *         This will be serialized as the non-public class
   *         {@link MatchQueryExp}.
   */
  public static QueryExp anySubString(AttributeValueExp attrib,
                                      StringValueExp string)
  {
    return new MatchQueryExp(attrib, "*" + string.getValue() + "*");
  }
 
  /**
   * Returns a value expression for the value of the
   * named attribute.  Evaluating this using an
   * {@link ObjectName} involves an underlying call
   * to {@link MBeanServer#getAttribute(ObjectName,String)}.
   *
   * @param name the name of the attribute.
   * @return a value expression which returns the value
   *         of the named attribute when applied.
   */
  public static AttributeValueExp attr(String name)
  {
    return new AttributeValueExp(name);
  }
 
  /**
   * Returns a value expression for the value of the
   * named attribute from the specified class.  Evaluating
   * this using an {@link ObjectName} involves an underlying call
   * to both {@link MBeanServer#getObjectInstance(ObjectName)} and
   * {@link MBeanServer#getAttribute(ObjectName,String)}.
   *
   * @param className the class containing the attribute.
   * @param name the name of the attribute.
   * @return a value expression which returns the value
   *         of the named attribute when applied.
   *         This will be serialized as the non-public class
   *         {@link QualifiedAttributeValueExp}.
   */
  public static AttributeValueExp attr(String className,
                                       String name)
  {
    return new QualifiedAttributeValueExp(className, name);
  }
 
  /**
   * Returns a query expression representing the constraint
   * that the value, <code>v1</code>, lies between <code>v2</code>
   * and <code>v3</code>.
   *
   * @param v1 the value to compare against the boundaries.
   * @param v2 the lower boundary.
   * @param v3 the upper boundary.
   * @return a query expression representing a comparison
   *         of <code>v1</code> against <code>v2</code>
   *         and <code>v3</code>.  It returns true if
   *         <code>v2 <= v1 <= v3</code>.  This
   *         will be serialized as the non-public class
   *         {@link BetweenQueryExp}.
   */
  public static QueryExp between(ValueExp v1, ValueExp v2,
                                 ValueExp v3)
  {
    return new BetweenQueryExp(v1, v2, v3);
  }
 
  /**
   * Returns a value expression which evaluates to the name of
   * the class of the bean when applied. Associating the expression
   * with an {@link ObjectName} involves an underlying call
   * to both {@link MBeanServer#getObjectInstance(ObjectName)}
   * to obtain this information.
   *
   * @return a value expression which returns the class name
   *         of the bean to which it is applied.
   *         This will be serialized as the non-public class
   *         {@link ClassAttributeValueExp}.
   */
  public static AttributeValueExp classattr()
  {
    return new ClassAttributeValueExp();
  }
 
  /**
   * Returns a value expression which evaluates to the result of
   * dividing <code>v1</code> by <code>v2</code>.
   *
   * @param v1 the left-hand operand.
   * @param v2 the right-hand operand.
   * @return a value expression which returns the result of
   *         the division when applied.  This will be serialized
   *         as the non-public class {@link BinaryOpValueExp}
   *         with an operation of {@link #DIV}.
   */
  public static ValueExp div(ValueExp v1, ValueExp v2)
  {
    return new BinaryOpValueExp(DIV, v1, v2);
  }
 
  /**
   * Returns a query expression which evaluates to the result of
   * comparing <code>v1</code> to <code>v2</code> for equality.
   *
   * @param v1 the left-hand operand.
   * @param v2 the right-hand operand.
   * @return a value expression which returns the result of
   *         the comparison when applied.  This will be serialized
   *         as the non-public class {@link BinaryRelQueryExp}
   *         with an operation of {@link #EQ}.
   */
  public static QueryExp eq(ValueExp v1, ValueExp v2)
  {
    return new BinaryRelQueryExp(EQ, v1, v2);
  }
 
  /**
   * Returns a query expression which checks that an
   * attribute value held by the specified
   * {@link AttributeValueExp} ends with the string
   * specified by the given {@link StringValueExp}.
   *
   * @param attrib the attribute to match.
   * @param string the substring to find.
   * @return a query expression representing
   *         <code>attrib.matches("*" + string)</code>.
   *         This will be serialized as the non-public class
   *         {@link MatchQueryExp}.
   */
  public static QueryExp finalSubString(AttributeValueExp attrib,
                                        StringValueExp string)
  {
    return new MatchQueryExp(attrib, "*" + string.getValue());
  }
 
  /**
   * Returns a query expression which evaluates to the result of
   * comparing <code>v1</code> to <code>v2</code> to see if
   * <code>v1</code> is greater than or equal to <code>v2</code>.
   *
   * @param v1 the left-hand operand.
   * @param v2 the right-hand operand.
   * @return a value expression which returns the result of
   *         the comparison when applied.  This will be serialized
   *         as the non-public class {@link BinaryRelQueryExp}
   *         with an operation of {@link #GE}.
   */
  public static QueryExp geq(ValueExp v1, ValueExp v2)
  {
    return new BinaryRelQueryExp(GE, v1, v2);
  }
 
  /**
   * Returns a query expression which evaluates to the result of
   * comparing <code>v1</code> to <code>v2</code> to see if
   * <code>v1</code> is greater than <code>v2</code>.
   *
   * @param v1 the left-hand operand.
   * @param v2 the right-hand operand.
   * @return a value expression which returns the result of
   *         the comparison when applied.  This will be serialized
   *         as the non-public class {@link BinaryRelQueryExp}
   *         with an operation of {@link #GT}.
   */
  public static QueryExp gt(ValueExp v1, ValueExp v2)
  {
    return new BinaryRelQueryExp(GT, v1, v2);
  }
 
  /**
   * Returns a query expression representing the constraint
   * that the value, <code>v</code>, is a member of the
   * list, <code>vlist</code>.
   *
   * @param v the value to look for in the list.
   * @param vlist the list of allowed values.
   * @return a query expression representing a membership check
   *         of <code>v</code> against the list, <code>vlist</code>.
   *         This will be serialized as the non-public class
   *         {@link InQueryExp}.
   */
  public static QueryExp in(ValueExp v, ValueExp[] vlist)
  {
    return new InQueryExp(v, vlist);
  }
 
  /**
   * Returns a query expression which checks that an
   * attribute value held by the specified
   * {@link AttributeValueExp} starts with the string
   * specified by the given {@link StringValueExp}.
   *
   * @param attrib the attribute to match.
   * @param string the substring to find.
   * @return a query expression representing
   *         <code>attrib.matches(string + "*")</code>.
   *         This will be serialized as the non-public class
   *         {@link MatchQueryExp}.
   */
  public static QueryExp initialSubString(AttributeValueExp attrib,
                                          StringValueExp string)
  {
    return new MatchQueryExp(attrib, string.getValue() + "*");
  }
 
  /**
   * Returns a query expression which checks that a
   * bean is an instance of the class specified
   * by the given {@link StringValueExp}.  Associating the
   * expression with an {@link ObjectName} involves an underlying
   * call to {@link MBeanServer#isInstanceOf(ObjectName, String)}
   * using the value of <code>((StringValueExp)
   * className.apply(objectName)).getValue()</code> as the
   * class name.
   *
   * @param className the name of the class which the bean
   *                  should be an instance of.
   * @return a query expression representing
   *         the inheritance check.  This will be serialized
   *         as the non-public class {@link InstanceOfQueryExp}.
   * @since 1.6
   */
  public static QueryExp isInstanceOf(StringValueExp className)
  {
    return new InstanceOfQueryExp(className);
  }
 
  /**
   * Returns a query expression which evaluates to the result of
   * comparing <code>v1</code> to <code>v2</code> to see if
   * <code>v1</code> is less than or equal to <code>v2</code>.
   *
   * @param v1 the left-hand operand.
   * @param v2 the right-hand operand.
   * @return a value expression which returns the result of
   *         the comparison when applied.  This will be serialized
   *         as the non-public class {@link BinaryRelQueryExp}
   *         with an operation of {@link #LE}.
   */
  public static QueryExp leq(ValueExp v1, ValueExp v2)
  {
    return new BinaryRelQueryExp(LE, v1, v2);
  }
 
  /**
   * Returns a query expression which evaluates to the result of
   * comparing <code>v1</code> to <code>v2</code> to see if
   * <code>v1</code> is less than <code>v2</code>.
   *
   * @param v1 the left-hand operand.
   * @param v2 the right-hand operand.
   * @return a value expression which returns the result of
   *         the comparison when applied.  This will be serialized
   *         as the non-public class {@link BinaryRelQueryExp}
   *         with an operation of {@link #LT}.
   */
  public static QueryExp lt(ValueExp v1, ValueExp v2)
  {
    return new BinaryRelQueryExp(LT, v1, v2);
  }
 
  /**
   * <p>
   * Returns a query expression which checks that an
   * attribute value matches the pattern
   * specified by the given {@link StringValueExp}.
   * The pattern uses file-globbing syntax:
   * </p>
   * <ul>
   * <li>'*' stands for any number of arbitrary characters.</li>
   * <li>'?' stands for a single arbitrary characters.</li>
   * <li>An expression within '[' and ']' specify a character
   * class.</li>
   * <ul>
   * <li>A range of characters can be specified by separating
   * the start and end character with '-'.</li>
   * <li>The complement of the class can be obtained by using
   * '!' as the first character of the class.</li>
   * <li>'?', '*' and '[' can occur freely within the class. '-'
   * may occur as the first or last character.  '!' may occur
   * normally in any position other than the first.  ']' may occur
   * as the first element of the class.</li>
   * </ul>
   * <li>'?', '*' and '[' may be escaped using a backslash
   * character, '\'.</li>
   * </ul>
   *
   * @param attrib the attribute to match.
   * @param string the substring to find.
   * @return a query expression representing the result of
   *         matching the pattern against the evaluated
   *         value of the attribute.  This will be serialized
   *         as the non-public class {@link MatchQueryExp}.
   */
  public static QueryExp match(AttributeValueExp attrib,
                               StringValueExp string)
  {
    return new MatchQueryExp(attrib, string.getValue());
  }
 
  /**
   * Returns a value expression which evaluates to the result of
   * subtracting <code>v2</code> from <code>v1</code>.
   *
   * @param v1 the left-hand operand.
   * @param v2 the right-hand operand.
   * @return a value expression which returns the result of
   *         the subtraction when applied.  This will be serialized
   *         as the non-public class {@link BinaryOpValueExp}
   *         with an operation of {@link #MINUS}.
   */
  public static ValueExp minus(ValueExp v1, ValueExp v2)
  {
    return new BinaryOpValueExp(MINUS, v1, v2);
  }
 
  /**
   * Returns a query expression representing the negation
   * of the specified query expression.
   *
   * @param q the query to negate.
   * @return a query expression representing the negation of
   *         <code>q</code>.  This will be serialized as the
   *         non-public class {@link NotQueryExp}.
   */
  public static QueryExp not(QueryExp q)
  {
    return new NotQueryExp(q);
  }
 
  /**
   * Returns a query expression formed from the disjunction
   * of the two supplied query expressions.
   *
   * @param q1 the first query expression.
   * @param q2 the second query expression.
   * @return a query expression representing q1 || q2.  This
   *         will be serialized as the non-public class
   *         {@link OrQueryExp}.
   */
  public static QueryExp or(QueryExp q1, QueryExp q2)
  {
    return new OrQueryExp(q1, q2);
  }
 
  /**
   * Returns a value expression which evaluates to the result of
   * adding <code>v1</code> to <code>v2</code>.
   *
   * @param v1 the left-hand operand.
   * @param v2 the right-hand operand.
   * @return a value expression which returns the result of
   *         the addition when applied.  This will be serialized
   *         as the non-public class {@link BinaryOpValueExp}
   *         with an operation of {@link #PLUS}.
   */
  public static ValueExp plus(ValueExp v1, ValueExp v2)
  {
    return new BinaryOpValueExp(PLUS, v1, v2);
  }
 
  /**
   * Returns a value expression which evaluates to the result of
   * multiplying <code>v1</code> by <code>v2</code>.
   *
   * @param v1 the left-hand operand.
   * @param v2 the right-hand operand.
   * @return a value expression which returns the result of
   *         the multiplication when applied.  This will be serialized
   *         as the non-public class {@link BinaryOpValueExp}
   *         with an operation of {@link #TIMES}.
   */
  public static ValueExp times(ValueExp v1, ValueExp v2)
  {
    return new BinaryOpValueExp(TIMES, v1, v2);
  }
 
  /**
   * Returns a value expression wrapping the specified value.
   *
   * @param val the boolean value to wrap.
   * @return a value expression wrapping <code>val</code>.  This
   *         will be serialized as the non-public class
   *         {@link BooleanValueExp}.
   */
  public static ValueExp value(boolean val)
  {
    return new BooleanValueExp(val);
  }
 
  /**
   * Returns a value expression wrapping the specified value.
   *
   * @param val the double value to wrap.
   * @return a value expression wrapping <code>val</code>.  This
   *         will be serialized as the non-public class
   *         {@link NumericValueExp}.
   */
  public static ValueExp value(double val)
  {
    return new NumericValueExp(val);
  }
 
  /**
   * Returns a value expression wrapping the specified value.
   *
   * @param val the float value to wrap.
   * @return a value expression wrapping <code>val</code>.  This
   *         will be serialized as the non-public class
   *         {@link NumericValueExp}.
   */
  public static ValueExp value(float val)
  {
    return new NumericValueExp(val);
  }
 
  /**
   * Returns a value expression wrapping the specified value.
   *
   * @param val the integer value to wrap.
   * @return a value expression wrapping <code>val</code>.  This
   *         will be serialized as the non-public class
   *         {@link NumericValueExp}.
   */
  public static ValueExp value(int val)
  {
    return new NumericValueExp(val);
  }
 
  /**
   * Returns a value expression wrapping the specified value.
   *
   * @param val the long value to wrap.
   * @return a value expression wrapping <code>val</code>.  This
   *         will be serialized as the non-public class
   *         {@link NumericValueExp}.
   */
  public static ValueExp value(long val)
  {
    return new NumericValueExp(val);
  }
 
  /**
   * Returns a value expression wrapping the specified value.
   *
   * @param val the {@link Number} value to wrap.
   * @return a value expression wrapping <code>val</code>.  This
   *         will be serialized as the non-public class
   *         {@link NumericValueExp}.
   */
  public static ValueExp value(Number val)
  {
    return new NumericValueExp(val);
  }
 
  /**
   * Returns a value expression wrapping the specified string.
   *
   * @param val the {@link String} to wrap.
   * @return a {@link StringValueExp} wrapping <code>val</code>.
   */
  public static StringValueExp value(String val)
  {
    return new StringValueExp(val);
  }
 
  /**
   * Representation of the conjunction formed using
   * {@link #and(QueryExp, QueryExp).
   *
   * @author Andrew John Hughes (gnu_andrew@member.fsf.org)
   * @since 1.5
   */
  private static final class AndQueryExp
    extends QueryEval
    implements QueryExp
  {
 
    /**
     * Compatible with JDK 1.6
     */
    private static final long serialVersionUID = -1081892073854801359L;
 
    /**
     * The first operand.
     */
    private QueryExp exp1;
 
    /**
     * The second operand.
     */
    private QueryExp exp2;
 
    /**
     * Constructs a new {@link AndQueryExp} using
     * the two specified operands.
     *
     * @param exp1 the first query expression.
     * @param exp2 the second query expression.
     */
    public AndQueryExp(QueryExp exp1, QueryExp exp2)
    {
      this.exp1 = exp1;
      this.exp2 = exp2;
    }
 
    /**
     * Returns the conjunction of the two query
     * expressions.
     *
     * @param name the {@link ObjectName} to apply
     *             the query to.
     * @return the conjunction of applying the name
     *         to both operands.
     * @throws BadStringOperationException if an invalid string
     *                                     operation is used by
     *                                     the query.
     * @throws BadBinaryOpValueExpException if an invalid expression
     *                                      is used by the query.
     * @throws BadAttributeValueExpException if an invalid attribute
     *                                       is used by the query.
     * @throws InvalidApplicationException if the query is applied
     *                                     to the wrong type of bean.
     */
    public boolean apply(ObjectName name)
      throws BadStringOperationException, BadBinaryOpValueExpException,
             BadAttributeValueExpException, InvalidApplicationException
    {
      return exp1.apply(name) && exp2.apply(name);
    }
 
  }
 
  /**
   * Representation of a query that matches an
   * attribute's value against a given pattern.
   *
   * @author Andrew John Hughes (gnu_andrew@member.fsf.org)
   * @since 1.5
   */
  private static final class MatchQueryExp
    extends QueryEval
    implements QueryExp
  {
 
    /**
     * Compatible with JDK 1.6
     */
    private static final long serialVersionUID = -7156603696948215014L;
 
    /**
     * The attribute to match against.
     */
    private AttributeValueExp exp;
 
    /**
     * The pattern to be matched.
     */
    private String pattern;
 
    /**
     * Constructs a new {@link MatchQueryExp} using
     * the specified attribute value and pattern.
     *
     * @param exp the attribute value expression.
     * @param pattern the pattern.
     */
    public MatchQueryExp(AttributeValueExp exp,
                         String pattern)
    {
      this.exp = exp;
      this.pattern = pattern;
    }
 
    /**
     * Returns the result of matching the attribute
     * value against the pattern.
     *
     * @param name the {@link ObjectName} to apply
     *             the query to.
     * @return the result of the match.
     * @throws BadStringOperationException if an invalid string
     *                                     operation is used by
     *                                     the query.
     * @throws BadBinaryOpValueExpException if an invalid expression
     *                                      is used by the query.
     * @throws BadAttributeValueExpException if an invalid attribute
     *                                       is used by the query.
     * @throws InvalidApplicationException if the query is applied
     *                                     to the wrong type of bean.
     */
    public boolean apply(ObjectName name)
      throws BadStringOperationException, BadBinaryOpValueExpException,
             BadAttributeValueExpException, InvalidApplicationException
    {
      String val = ((StringValueExp) exp.apply(name)).getValue();
      int valPos = 0;
      int fallback = -1;
      int fallbackP = -1;
      boolean backslash = false;
      for (int a = 0; a < pattern.length(); ++a)
        {
          boolean matched = false;
          int next = pattern.codePointAt(a);
          if (!backslash)
            {
              if (next == '?' && valPos < val.length())
                {
                  ++valPos;
                  matched = true;
                }
              else if (next == '*')
                {
                  fallback = valPos;
                  fallbackP = a;
                  matched = true;
                }
              else if (next == '[' && valPos < val.length())
                {
                  boolean negated = false;
                  int b = a + 1;
                  int classChar = pattern.codePointAt(b);
                  do
                    {
                      if (classChar == '!' && b == a + 1)
                        negated = true;
                      else if (pattern.codePointAt(b + 1) == '-' &&
                               pattern.codePointAt(b + 2) != ']')
                        {
                          if (classChar > pattern.codePointAt(b + 2))
                            throw new BadStringOperationException("Invalid range: " +
                                                                  classChar + " to " +
                                                                  pattern.codePointAt(b+2));
                          for (int c = classChar; c <= pattern.codePointAt(b+2); ++c)
                            if (val.codePointAt(valPos) == c)
                              matched = true;
                          b = b + 2;
                        }
                      else if (val.codePointAt(valPos) == classChar)
                        matched = true;
                      ++b;
                      classChar = pattern.codePointAt(b);
                    } while (classChar != ']');
                  if (negated)
                    matched = !matched;
                  ++valPos;
                  a = b;
                }
              else if (next == '\\')
                backslash = true;
              else if (valPos < val.length() && next == val.codePointAt(valPos))
                {
                  matched = true;
                  ++valPos;
                }
            }
          else
            {
              backslash = false;
              if (valPos < val.length() && next == val.codePointAt(valPos))
                {
                  matched = true;
                  ++valPos;
                }
            }
          if (!matched)
            if (fallback != -1)
              {
                ++fallback;
                valPos = fallback;
                a = fallbackP;
                if (valPos == val.length())
                  return false;
                continue;
              }
            else
              return false;
        }
      return true;
    }
  }
 
  /**
   * Representation of the retrieval of an attribute
   * value from a certain class for {@link #attr(String,String)}.
   *
   * @author Andrew John Hughes (gnu_andrew@member.fsf.org)
   * @since 1.5
   */
  private static final class QualifiedAttributeValueExp
    extends AttributeValueExp
  {
 
    /**
     * Compatible with JDK 1.6
     */
    private static final long serialVersionUID = 8832517277410933254L;
 
    /**
     * The name of the class from which the attribute is taken.
     */
    private String className;
 
    /**
     * Constructs a new {@link QualifiedAttributeValueExp} using
     * the specified class name and attribute name.
     *
     * @param className the class name.
     * @param name the attribute name.
     */
    public QualifiedAttributeValueExp(String className, String name)
    {
      super(name);
      this.className = className;
    }
 
    /**
     * Applies the {@link AttributeValueExp} to the specified
     * management bean by checking that the attribute will be
     * obtained from the correct class (by a class to
     * {@link MBeanServer#getObjectInstance(ObjectName)} and
     * then obtaining the attribute value from the
     * {@link MBeanServer}, using it to create a
     * {@link StringValueExp}.
     *
     * @param name the {@link ObjectName} of the bean to obtain
     *             the value from.
     * @return a {@link StringValueExp} containing the result.
     * @throws BadStringOperationException if an invalid string
     *                                     operation is used by
     *                                     the value expression.
     * @throws BadBinaryOpValueExpException if an invalid expression
     *                                      is used by the value expression.
     * @throws BadAttributeValueExpException if an invalid attribute
     *                                       is used by the value expression.
     * @throws InvalidApplicationException if the value expression is applied
     *                                     to the wrong type of bean.
     */
    public ValueExp apply(ObjectName name)
      throws BadStringOperationException, BadBinaryOpValueExpException,
             BadAttributeValueExpException, InvalidApplicationException
    {
      try
        {
          if (!(QueryEval.getMBeanServer().getObjectInstance(name).getClassName().equals(className)))
            throw new BadAttributeValueExpException("The value is not from " +
                                                    "the correct class.");
        }
      catch (InstanceNotFoundException e)
        {
          throw (BadAttributeValueExpException)
            new BadAttributeValueExpException("The named bean is not registered.").initCause(e);
        }
      return super.apply(name);
    }
 
  }
 
  /**
   * Representation of the comparison of a value with
   * a pair of bounds formed using
   * {@link #between(ValueExp, ValueExp, ValueExp).
   *
   * @author Andrew John Hughes (gnu_andrew@member.fsf.org)
   * @since 1.5
   */
  private static final class BetweenQueryExp
    extends QueryEval
    implements QueryExp
  {
 
    /**
     * Compatible with JDK 1.6
     */
    private static final long serialVersionUID = -2933597532866307444L;
 
    /**
     * The value to compare.
     */
    private ValueExp exp1;
 
    /**
     * The lower boundary.
     */
    private ValueExp exp2;
 
    /**
     * The upper boundary.
     */
    private ValueExp exp3;
 
    /**
     * Constructs a new {@link BetweenQueryExp} using
     * the specified comparison value and the given
     * bounds.
     *
     * @param exp1 the value to compare.
     * @param exp2 the lower bound.
     * @param exp3 the upper bound.
     */
    public BetweenQueryExp(ValueExp exp1, ValueExp exp2,
                           ValueExp exp3)
    {
      this.exp1 = exp1;
      this.exp2 = exp2;
      this.exp3 = exp3;
    }
 
    /**
     * Returns the result of the comparison between
     * the value and the two bounds.
     *
     * @param name the {@link ObjectName} to apply
     *             the query to.
     * @return the result of the comparison.
     * @throws BadStringOperationException if an invalid string
     *                                     operation is used by
     *                                     the query.
     * @throws BadBinaryOpValueExpException if an invalid expression
     *                                      is used by the query.
     * @throws BadAttributeValueExpException if an invalid attribute
     *                                       is used by the query.
     * @throws InvalidApplicationException if the query is applied
     *                                     to the wrong type of bean.
     */
    public boolean apply(ObjectName name)
      throws BadStringOperationException, BadBinaryOpValueExpException,
             BadAttributeValueExpException, InvalidApplicationException
    {
      String v1 = exp1.apply(name).toString();
      String v2 = exp2.apply(name).toString();
      String v3 = exp3.apply(name).toString();
      return v1.compareTo(v2) >= 0 && v1.compareTo(v3) <= 0;
    }
 
  }
 
  /**
   * Representation of the retrieval of the name of
   * a bean's class for {@link #classattr()}.
   *
   * @author Andrew John Hughes (gnu_andrew@member.fsf.org)
   * @since 1.5
   */
  private static final class ClassAttributeValueExp
    extends AttributeValueExp
  {
 
    /**
     * Compatible with JDK 1.6
     */
    private static final long serialVersionUID = -1081892073854801359L;
 
    /**
     * Obtains the name of the specified bean's class using a call
     * to {@link MBeanServer#getObjectInstance(ObjectName)}.
     *
     * @param name the {@link ObjectName} of the bean to obtain
     *             the class name from.
     * @return a {@link StringValueExp} containing the result.
     * @throws BadStringOperationException if an invalid string
     *                                     operation is used by
     *                                     the value expression.
     * @throws BadBinaryOpValueExpException if an invalid expression
     *                                      is used by the value expression.
     * @throws BadAttributeValueExpException if an invalid attribute
     *                                       is used by the value expression.
     * @throws InvalidApplicationException if the value expression is applied
     *                                     to the wrong type of bean.
     */
    public ValueExp apply(ObjectName name)
      throws BadStringOperationException, BadBinaryOpValueExpException,
             BadAttributeValueExpException, InvalidApplicationException
    {
      try
        {
          return new StringValueExp(QueryEval.getMBeanServer().getObjectInstance(name).getClassName());
        }
      catch (InstanceNotFoundException e)
        {
          throw (BadAttributeValueExpException)
            new BadAttributeValueExpException("The named bean is not registered.").initCause(e);
        }
    }
 
  }
 
  /**
   * Representation of a binary operation formed using
   * {@link #div(ValueExp, ValueExp), {@link #plus(ValueExp,ValueExp)},
   * {@link #minus(ValueExp, ValueExp) or
   * {@link #times(ValueExp, ValueExp)}.
   *
   * @author Andrew John Hughes (gnu_andrew@member.fsf.org)
   * @since 1.5
   */
  private static final class BinaryOpValueExp
    extends QueryEval
    implements ValueExp
  {
 
    /**
     * Compatible with JDK 1.6
     */
    private static final long serialVersionUID = 1216286847881456786L;
 
    /**
     * The operation to perform.
     */
    private int op;
 
    /**
     * The left-hand operand.
     */
    private ValueExp exp1;
 
    /**
     * The right-hand operand.
     */
    private ValueExp exp2;
 
    /**
     * Constructs a new {@link BinaryOpValueExp} using
     * the specified operation and the two values supplied.
     *
     * @param op the operation to perform.
     * @param exp1 the left-hand operand.
     * @param exp2 the right-hand operand.
     */
    public BinaryOpValueExp(int op, ValueExp exp1, ValueExp exp2)
    {
      this.op = op;
      this.exp1 = exp1;
      this.exp2 = exp2;
    }
 
    /**
     * Returns the result of performing the operation on
     * <code>exp1</code> and <code>exp2</code>.
     *
     * @param name the {@link ObjectName} to apply
     *             the query to.
     * @return the result of the operation.
     * @throws BadStringOperationException if an invalid string
     *                                     operation is used by
     *                                     the query.
     * @throws BadBinaryOpValueExpException if an invalid expression
     *                                      is used by the query.
     * @throws BadAttributeValueExpException if an invalid attribute
     *                                       is used by the query.
     * @throws InvalidApplicationException if the query is applied
     *                                     to the wrong type of bean.
     */
    public ValueExp apply(ObjectName name)
      throws BadStringOperationException, BadBinaryOpValueExpException,
             BadAttributeValueExpException, InvalidApplicationException
    {
      NumericValueExp v1 = (NumericValueExp) exp1.apply(name);
      NumericValueExp v2 = (NumericValueExp) exp2.apply(name);
      switch (op)
        {
        case PLUS:
          return v1.plus(v2);
        case MINUS:
          return v1.minus(v2);
        case TIMES:
          return v1.times(v2);
        case DIV:
          return v1.div(v2);
        default:
          throw new BadBinaryOpValueExpException(this);
        }
    }
 
    /**
     * Returns a textual representation of the operation.
     *
     * @return a textual version of the operation.
     */
    public String toString()
    {
      String opS;
      switch (op)
        {
        case PLUS:
          opS = "+";
          break;
        case MINUS:
          opS = "-";
          break;
        case TIMES:
          opS = "x";
          break;
        case DIV:
          opS = "/";
          break;
        default:
          opS = "?";
        }
      return exp1 + " " + opS + " " + exp2;
    }
  }
 
  /**
   * Representation of a binary operation formed using
   * {@link #eq(ValueExp, ValueExp), {@link #geq(ValueExp, ValueExp)},
   * {@link #leq(ValueExp, ValueExp), {@link #gt(ValueExp, ValueExp)}
   * or {@link #lt(ValueExp, ValueExp)}.
   *
   * @author Andrew John Hughes (gnu_andrew@member.fsf.org)
   * @since 1.5
   */
  private static final class BinaryRelQueryExp
    extends QueryEval
    implements QueryExp
  {
 
    /**
     * Compatible with JDK 1.6
     */
    private static final long serialVersionUID = -5690656271650491000L;
 
    /**
     * The operation to perform.
     */
    private int relOp;
 
    /**
     * The left-hand operand.
     */
    private ValueExp exp1;
 
    /**
     * The right-hand operand.
     */
    private ValueExp exp2;
 
    /**
     * Constructs a new {@link BinaryRelQueryExp} using
     * the specified operation and the two values supplied.
     *
     * @param relOp the operation to perform.
     * @param exp1 the left-hand operand.
     * @param exp2 the right-hand operand.
     */
    public BinaryRelQueryExp(int relOp, ValueExp exp1, ValueExp exp2)
    {
      this.relOp = relOp;
      this.exp1 = exp1;
      this.exp2 = exp2;
    }
 
    /**
     * Returns the result of performing the operation on
     * <code>exp1</code> and <code>exp2</code>.
     *
     * @param name the {@link ObjectName} to apply
     *             the query to.
     * @return the result of the comparison.
     * @throws BadStringOperationException if an invalid string
     *                                     operation is used by
     *                                     the query.
     * @throws BadBinaryOpValueExpException if an invalid expression
     *                                      is used by the query.
     * @throws BadAttributeValueExpException if an invalid attribute
     *                                       is used by the query.
     * @throws InvalidApplicationException if the query is applied
     *                                     to the wrong type of bean.
     */
    public boolean apply(ObjectName name)
      throws BadStringOperationException, BadBinaryOpValueExpException,
             BadAttributeValueExpException, InvalidApplicationException
    {
      String v1 = exp1.apply(name).toString();
      String v2 = exp2.apply(name).toString();
      switch (relOp)
        {
        case EQ:
          return v1.equals(v2);
        case GT:
          return v1.compareTo(v2) > 0;
        case GE:
          return v1.compareTo(v2) >= 0;
        case LE:
          return v1.compareTo(v2) <= 0;
        case LT:
          return v1.compareTo(v2) < 0;
        default:
          throw new BadStringOperationException("Invalid operator: " + relOp);
        }
    }
 
    /**
     * Returns a textual representation of the operation.
     *
     * @return a textual version of the operation.
     */
    public String toString()
    {
      String op;
      switch (relOp)
        {
        case EQ:
          op = "=";
          break;
        case GT:
          op = ">";
          break;
        case GE:
          op = ">=";
          break;
        case LE:
          op = "<=";
          break;
        case LT:
          op = "<";
          break;
        default:
          op = "?";
        }
      return exp1 + " " + op + " " + exp2;
    }
  }
 
  /**
   * Representation of the comparison of a value with
   * the members of a list formed using
   * {@link #in(ValueExp, ValueExp[]).
   *
   * @author Andrew John Hughes (gnu_andrew@member.fsf.org)
   * @since 1.5
   */
  private static final class InQueryExp
    extends QueryEval
    implements QueryExp
  {
 
    /**
     * Compatible with JDK 1.6
     */
    private static final long serialVersionUID = -5801329450358952434L;
 
    /**
     * The value to look for.
     */
    private ValueExp val;
 
    /**
     * The array to search.
     */
    private ValueExp[] valueList;
 
    /**
     * Constructs a new {@link InQueryExp} using
     * the specified comparison value and the given
     * list.
     *
     * @param val the value to compare.
     * @param valueList the list of values.
     */
    public InQueryExp(ValueExp val, ValueExp[] valueList)
    {
      this.val = val;
      this.valueList = valueList;
    }
 
    /**
     * Returns the result of the comparison between
     * the value and the list of allowed values.
     *
     * @param name the {@link ObjectName} to apply
     *             the query to.
     * @return the result of the comparison.
     * @throws BadStringOperationException if an invalid string
     *                                     operation is used by
     *                                     the query.
     * @throws BadBinaryOpValueExpException if an invalid expression
     *                                      is used by the query.
     * @throws BadAttributeValueExpException if an invalid attribute
     *                                       is used by the query.
     * @throws InvalidApplicationException if the query is applied
     *                                     to the wrong type of bean.
     */
    public boolean apply(ObjectName name)
      throws BadStringOperationException, BadBinaryOpValueExpException,
             BadAttributeValueExpException, InvalidApplicationException
    {
      String v = val.apply(name).toString();
      for (ValueExp vl : valueList)
        if (v.equals(vl.apply(name).toString()))
          return true;
      return false;
    }
 
  }
 
  /**
   * Representation of the inheritance check on a
   * bean for {@link #isInstanceOf(StringValueExp)}.
   *
   * @author Andrew John Hughes (gnu_andrew@member.fsf.org)
   * @since 1.6
   */
  private static final class InstanceOfQueryExp
    extends QueryEval
    implements QueryExp
  {
 
    /**
     * Compatible with JDK 1.6
     */
    private static final long serialVersionUID = -1081892073854801359L;
 
    /**
     * The name of the class from which the attribute is taken.
     */
    private StringValueExp classNameValue;
 
    /**
     * Constructs a new {@link InstanceOfQueryExp} using
     * the specified class name.
     *
     * @param classNameValue the class name.
     */
    public InstanceOfQueryExp(StringValueExp classNameValue)
    {
      this.classNameValue = classNameValue;
    }
 
    /**
     * Checks that the bean specified by the supplied
     * {@link ObjectName} is of the correct class
     * using {@link MBeanServer#isInstanceOf(ObjectName,String)}.
     * where the string is obtained by evaluating
     * <code>classNameValue</code>.
     *
     * @param name the {@link ObjectName} of the bean to obtain
     *             the value from.
     * @return true if the bean is an instance of the class.
     * @throws BadStringOperationException if an invalid string
     *                                     operation is used by
     *                                     the value expression.
     * @throws BadBinaryOpValueExpException if an invalid expression
     *                                      is used by the value expression.
     * @throws BadAttributeValueExpException if an invalid attribute
     *                                       is used by the value expression.
     * @throws InvalidApplicationException if the value expression is applied
     *                                     to the wrong type of bean.
     */
    public boolean apply(ObjectName name)
      throws BadStringOperationException, BadBinaryOpValueExpException,
             BadAttributeValueExpException, InvalidApplicationException
    {
      try
        {
          String className = ((StringValueExp)
                              classNameValue.apply(name)).getValue();
          return QueryEval.getMBeanServer().isInstanceOf(name, className);
        }
      catch (InstanceNotFoundException e)
        {
          throw (BadAttributeValueExpException)
            new BadAttributeValueExpException("The named bean is not registered.").initCause(e);
        }
    }
 
  }
 
  /**
   * Representation of the negation of a query formed using
   * {@link #not(QueryExp).
   *
   * @author Andrew John Hughes (gnu_andrew@member.fsf.org)
   * @since 1.5
   */
  private static final class NotQueryExp
    extends QueryEval
    implements QueryExp
  {
 
    /**
     * Compatible with JDK 1.6
     */
    private static final long serialVersionUID = 5269643775896723397L;
 
    /**
     * The expression to negate.
     */
    private QueryExp exp;
 
    /**
     * Constructs a new {@link NotQueryExp} using
     * the specified query expression.
     *
     * @param exp the expression to negate.
     */
    public NotQueryExp(QueryExp exp)
    {
      this.exp = exp;
    }
 
    /**
     * Returns the result of the negation.
     *
     * @param name the {@link ObjectName} to apply
     *             the query to.
     * @return the result of the negation.
     * @throws BadStringOperationException if an invalid string
     *                                     operation is used by
     *                                     the query.
     * @throws BadBinaryOpValueExpException if an invalid expression
     *                                      is used by the query.
     * @throws BadAttributeValueExpException if an invalid attribute
     *                                       is used by the query.
     * @throws InvalidApplicationException if the query is applied
     *                                     to the wrong type of bean.
     */
    public boolean apply(ObjectName name)
      throws BadStringOperationException, BadBinaryOpValueExpException,
             BadAttributeValueExpException, InvalidApplicationException
    {
      return !(exp.apply(name));
    }
 
  }
 
  /**
   * Representation of the disjunction formed using
   * {@link #or(QueryExp, QueryExp).
   *
   * @author Andrew John Hughes (gnu_andrew@member.fsf.org)
   * @since 1.5
   */
  private static final class OrQueryExp
    extends QueryEval
    implements QueryExp
  {
 
    /**
     * Compatible with JDK 1.6
     */
    private static final long serialVersionUID = 2962973084421716523L;
 
    /**
     * The first operand.
     */
    private QueryExp exp1;
 
    /**
     * The second operand.
     */
    private QueryExp exp2;
 
    /**
     * Constructs a new {@link OrQueryExp} using
     * the two specified operands.
     *
     * @param exp1 the first query expression.
     * @param exp2 the second query expression.
     */
    public OrQueryExp(QueryExp exp1, QueryExp exp2)
    {
      this.exp1 = exp1;
      this.exp2 = exp2;
    }
 
    /**
     * Returns the disjunction of the two query
     * expressions.
     *
     * @param name the {@link ObjectName} to apply
     *             the query to.
     * @return the disjunction of applying the name
     *         to both operands.
     * @throws BadStringOperationException if an invalid string
     *                                     operation is used by
     *                                     the query.
     * @throws BadBinaryOpValueExpException if an invalid expression
     *                                      is used by the query.
     * @throws BadAttributeValueExpException if an invalid attribute
     *                                       is used by the query.
     * @throws InvalidApplicationException if the query is applied
     *                                     to the wrong type of bean.
     */
    public boolean apply(ObjectName name)
      throws BadStringOperationException, BadBinaryOpValueExpException,
             BadAttributeValueExpException, InvalidApplicationException
    {
      return exp1.apply(name) || exp2.apply(name);
    }
 
  }
 
  /**
   * Representation of a boolean being used as an argument
   * to a relational constraint, formed using
   * {@link #value(boolean)}.
   *
   * @author Andrew John Hughes (gnu_andrew@member.fsf.org)
   * @since 1.5
   */
  private static final class BooleanValueExp
    extends QueryEval
    implements ValueExp
  {
 
    /**
     * Compatible with JDK 1.6
     */
    private static final long serialVersionUID = 7754922052666594581L;
 
    /**
     * The boolean value.
     */
    private boolean val;
 
    /**
     * Constructs a new {@link BooleanValueExp} using the
     * specified value.
     *
     * @param val the boolean value used for this expression.
     */
    public BooleanValueExp(boolean val)
    {
      this.val = val;
    }
 
    /**
     * Applies the {@link BooleanValueExp} to the specified
     * management bean by simply returning the value.
     *
     * @param name the {@link ObjectName} of the bean.
     * @return the {@link BooleanValueExp} itself.
     * @throws BadStringOperationException if an invalid string
     *                                     operation is used by
     *                                     the value expression.
     * @throws BadBinaryOpValueExpException if an invalid expression
     *                                      is used by the value expression.
     * @throws BadAttributeValueExpException if an invalid attribute
     *                                       is used by the value expression.
     * @throws InvalidApplicationException if the value expression is applied
     *                                     to the wrong type of bean.
     */
    public ValueExp apply(ObjectName name)
      throws BadStringOperationException, BadBinaryOpValueExpException,
             BadAttributeValueExpException, InvalidApplicationException
    {
      return this;
    }
 
    /**
     * Returns the value as a string.
     *
     * @return the value in textual form.
     */
    public String toString()
    {
      return Boolean.toString(val);
    }
 
  }
 
  /**
   * Representation of a number being used as an argument
   * to a relational constraint, formed using
   * {@link #value(double)}, {@link #value(float)},
   * {@link #value(int)}, {@link #value(long)} or
   * {@link #value(Number)}.
   *
   * @author Andrew John Hughes (gnu_andrew@member.fsf.org)
   * @since 1.5
   */
  private static final class NumericValueExp
    extends QueryEval
    implements ValueExp
  {
 
    /**
     * Compatible with JDK 1.6
     */
    private static final long serialVersionUID = -4679739485102359104L;
 
    /**
     * The numeric value.
     */
    private Number val;
 
    /**
     * Constructs a new {@link NumericValueExp} using the
     * specified value.
     *
     * @param val the numeric value used for this expression.
     */
    public NumericValueExp(Number val)
    {
      this.val = val;
    }
 
    /**
     * Applies the {@link NumericValueExp} to the specified
     * management bean by simply returning the value.
     *
     * @param name the {@link ObjectName} of the bean.
     * @return the {@link NumericValueExp} itself.
     * @throws BadStringOperationException if an invalid string
     *                                     operation is used by
     *                                     the value expression.
     * @throws BadBinaryOpValueExpException if an invalid expression
     *                                      is used by the value expression.
     * @throws BadAttributeValueExpException if an invalid attribute
     *                                       is used by the value expression.
     * @throws InvalidApplicationException if the value expression is applied
     *                                     to the wrong type of bean.
     */
    public ValueExp apply(ObjectName name)
      throws BadStringOperationException, BadBinaryOpValueExpException,
             BadAttributeValueExpException, InvalidApplicationException
    {
      return this;
    }
 
    /**
     * Returns the value.
     */
    public Number getValue()
    {
      return val;
    }
 
    /**
     * Returns the value as a string.
     *
     * @return the value in textual form.
     */
    public String toString()
    {
      return val.toString();
    }
 
    /**
     * Return the result of adding the specified
     * {@link NumericValueExp} to this one.
     *
     * @param o the value to add.
     * @return the result of the addition.
     */
    public NumericValueExp plus(NumericValueExp o)
    {
      Number v = o.getValue();
      if (val instanceof Double)
        {
          double d = val.doubleValue();
          if (v instanceof Double)
            return new NumericValueExp(d + v.doubleValue());
          else if (v instanceof Float)
            return new NumericValueExp(d + v.floatValue());
          else if (v instanceof Long)
            return new NumericValueExp(d + v.longValue());
          else
            return new NumericValueExp(d + v.intValue());
        }
      else if (val instanceof Float)
        {
          float f = val.floatValue();
          if (v instanceof Double)
            return new NumericValueExp(f + v.doubleValue());
          else if (v instanceof Float)
            return new NumericValueExp(f + v.floatValue());
          else if (v instanceof Long)
            return new NumericValueExp(f + v.longValue());
          else
            return new NumericValueExp(f + v.intValue());
        }
      else if (val instanceof Long)
        {
          long l = val.longValue();
          if (v instanceof Double)
            return new NumericValueExp(l + v.doubleValue());
          else if (v instanceof Float)
            return new NumericValueExp(l + v.floatValue());
          else if (v instanceof Long)
            return new NumericValueExp(l + v.longValue());
          else
            return new NumericValueExp(l + v.intValue());
        }
      int i = val.intValue();
      if (v instanceof Double)
        return new NumericValueExp(i + v.doubleValue());
      else if (v instanceof Float)
        return new NumericValueExp(i + v.floatValue());
      else if (v instanceof Long)
        return new NumericValueExp(i + v.longValue());
      else
        return new NumericValueExp(i + v.intValue());
    }
 
    /**
     * Return New NumericValueExp(the result of subtracting the specified
     * {@link NumericValueExp} from this one.
     *
     * @param o the value to subtract.
     * @return new NumericValueExp(the result of the subtraction.
     */
    public NumericValueExp minus(NumericValueExp o)
    {
      Number v = o.getValue();
      if (val instanceof Double)
        {
          double d = val.doubleValue();
          if (v instanceof Double)
            return new NumericValueExp(d - v.doubleValue());
          else if (v instanceof Float)
            return new NumericValueExp(d - v.floatValue());
          else if (v instanceof Long)
            return new NumericValueExp(d - v.longValue());
          else
            return new NumericValueExp(d - v.intValue());
        }
      else if (val instanceof Float)
        {
          float f = val.floatValue();
          if (v instanceof Double)
            return new NumericValueExp(f - v.doubleValue());
          else if (v instanceof Float)
            return new NumericValueExp(f - v.floatValue());
          else if (v instanceof Long)
            return new NumericValueExp(f - v.longValue());
          else
            return new NumericValueExp(f - v.intValue());
        }
      else if (val instanceof Long)
        {
          long l = val.longValue();
          if (v instanceof Double)
            return new NumericValueExp(l - v.doubleValue());
          else if (v instanceof Float)
            return new NumericValueExp(l - v.floatValue());
          else if (v instanceof Long)
            return new NumericValueExp(l - v.longValue());
          else
            return new NumericValueExp(l - v.intValue());
        }
      int i = val.intValue();
      if (v instanceof Double)
        return new NumericValueExp(i - v.doubleValue());
      else if (v instanceof Float)
        return new NumericValueExp(i - v.floatValue());
      else if (v instanceof Long)
        return new NumericValueExp(i - v.longValue());
      else
        return new NumericValueExp(i - v.intValue());
    }
 
    /**
     * Return New NumericValueExp(the result of multiplying the specified
     * {@link NumericValueExp} to this one.
     *
     * @param o the value to multiply by.
     * @return new NumericValueExp(the result of the multiplication.
     */
    public NumericValueExp times(NumericValueExp o)
    {
      Number v = o.getValue();
      if (val instanceof Double)
        {
          double d = val.doubleValue();
          if (v instanceof Double)
            return new NumericValueExp(d * v.doubleValue());
          else if (v instanceof Float)
            return new NumericValueExp(d * v.floatValue());
          else if (v instanceof Long)
            return new NumericValueExp(d * v.longValue());
          else
            return new NumericValueExp(d * v.intValue());
        }
      else if (val instanceof Float)
        {
          float f = val.floatValue();
          if (v instanceof Double)
            return new NumericValueExp(f * v.doubleValue());
          else if (v instanceof Float)
            return new NumericValueExp(f * v.floatValue());
          else if (v instanceof Long)
            return new NumericValueExp(f * v.longValue());
          else
            return new NumericValueExp(f * v.intValue());
        }
      else if (val instanceof Long)
        {
          long l = val.longValue();
          if (v instanceof Double)
            return new NumericValueExp(l * v.doubleValue());
          else if (v instanceof Float)
            return new NumericValueExp(l * v.floatValue());
          else if (v instanceof Long)
            return new NumericValueExp(l * v.longValue());
          else
            return new NumericValueExp(l * v.intValue());
        }
      int i = val.intValue();
      if (v instanceof Double)
        return new NumericValueExp(i * v.doubleValue());
      else if (v instanceof Float)
        return new NumericValueExp(i * v.floatValue());
      else if (v instanceof Long)
        return new NumericValueExp(i * v.longValue());
      else
        return new NumericValueExp(i * v.intValue());
    }
 
    /**
     * Return New NumericValueExp(the result of dividing this
     * number by value of the specified
     * {@link NumericValueExp}.
     *
     * @param o the value to divide by.
     * @return new NumericValueExp(the result of the division.
     */
    public NumericValueExp div(NumericValueExp o)
    {
      Number v = o.getValue();
      if (val instanceof Double)
        {
          double d = val.doubleValue();
          if (v instanceof Double)
            return new NumericValueExp(d / v.doubleValue());
          else if (v instanceof Float)
            return new NumericValueExp(d / v.floatValue());
          else if (v instanceof Long)
            return new NumericValueExp(d / v.longValue());
          else
            return new NumericValueExp(d / v.intValue());
        }
      else if (val instanceof Float)
        {
          float f = val.floatValue();
          if (v instanceof Double)
            return new NumericValueExp(f / v.doubleValue());
          else if (v instanceof Float)
            return new NumericValueExp(f / v.floatValue());
          else if (v instanceof Long)
            return new NumericValueExp(f / v.longValue());
          else
            return new NumericValueExp(f / v.intValue());
        }
      else if (val instanceof Long)
        {
          long l = val.longValue();
          if (v instanceof Double)
            return new NumericValueExp(l / v.doubleValue());
          else if (v instanceof Float)
            return new NumericValueExp(l / v.floatValue());
          else if (v instanceof Long)
            return new NumericValueExp(l / v.longValue());
          else
            return new NumericValueExp(l / v.intValue());
        }
      int i = val.intValue();
      if (v instanceof Double)
        return new NumericValueExp(i / v.doubleValue());
      else if (v instanceof Float)
        return new NumericValueExp(i / v.floatValue());
      else if (v instanceof Long)
        return new NumericValueExp(i / v.longValue());
      else
        return new NumericValueExp(i / v.intValue());
    }
 
  }
 
}