ojluni/src/main/java/javax/management/BinaryOpValueExp.java - platform/libcore - Git at Google

 /*
  * Copyright (c) 1999, 2008, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
  * under the terms of the GNU General Public License version 2 only, as
  * published by the Free Software Foundation.  Oracle designates this
  * particular file as subject to the "Classpath" exception as provided
  * by Oracle in the LICENSE file that accompanied this code.
  *
  * This code 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
  * version 2 for more details (a copy is included in the LICENSE file that
  * accompanied this code).
  *
  * You should have received a copy of the GNU General Public License version
  * 2 along with this work; if not, write to the Free Software Foundation,
  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  *
  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  * or visit www.oracle.com if you need additional information or have any
  * questions.
  */

 package javax.management;


 /**
  * This class is used by the query-building mechanism to represent binary
  * operations.
  * @serial include
  *
  * @since 1.5
  */
 class BinaryOpValueExp extends QueryEval implements ValueExp {

     /* Serial version */
     private static final long serialVersionUID = 1216286847881456786L;

     /**
      * @serial The operator
      */
     private int op;

     /**
      * @serial The first value
      */
     private ValueExp exp1;

     /**
      * @serial The second value
      */
     private ValueExp exp2;


     /**
      * Basic Constructor.
      */
     public BinaryOpValueExp() {
     }

     /**
      * Creates a new BinaryOpValueExp using operator o applied on v1 and
      * v2 values.
      */
     public BinaryOpValueExp(int o, ValueExp v1, ValueExp v2) {
         op   = o;
         exp1 = v1;
         exp2 = v2;
     }


     /**
      * Returns the operator of the value expression.
      */
     public int getOperator()  {
         return op;
     }

     /**
      * Returns the left value of the value expression.
      */
     public ValueExp getLeftValue()  {
         return exp1;
     }

     /**
      * Returns the right value of the value expression.
      */
     public ValueExp getRightValue()  {
         return exp2;
     }

     /**
      * Applies the BinaryOpValueExp on a MBean.
      *
      * @param name The name of the MBean on which the BinaryOpValueExp will be applied.
      *
      * @return  The ValueExp.
      *
      * @exception BadStringOperationException
      * @exception BadBinaryOpValueExpException
      * @exception BadAttributeValueExpException
      * @exception InvalidApplicationException
      */
     public ValueExp apply(ObjectName name) throws BadStringOperationException, BadBinaryOpValueExpException,
         BadAttributeValueExpException, InvalidApplicationException  {
         ValueExp val1 = exp1.apply(name);
         ValueExp val2 = exp2.apply(name);
         String sval1;
         String sval2;
         double dval1;
         double dval2;
         long   lval1;
         long   lval2;
         boolean numeric = val1 instanceof NumericValueExp;

         if (numeric) {
             if (((NumericValueExp)val1).isLong()) {
                 lval1 = ((NumericValueExp)val1).longValue();
                 lval2 = ((NumericValueExp)val2).longValue();

                 switch (op) {
                 case Query.PLUS:
                     return Query.value(lval1 + lval2);
                 case Query.TIMES:
                     return Query.value(lval1 * lval2);
                 case Query.MINUS:
                     return Query.value(lval1 - lval2);
                 case Query.DIV:
                     return Query.value(lval1 / lval2);
                 }

             } else {
                 dval1 = ((NumericValueExp)val1).doubleValue();
                 dval2 = ((NumericValueExp)val2).doubleValue();

                 switch (op) {
                 case Query.PLUS:
                     return Query.value(dval1 + dval2);
                 case Query.TIMES:
                     return Query.value(dval1 * dval2);
                 case Query.MINUS:
                     return Query.value(dval1 - dval2);
                 case Query.DIV:
                     return Query.value(dval1 / dval2);
                 }
             }
         } else {
             sval1 = ((StringValueExp)val1).getValue();
             sval2 = ((StringValueExp)val2).getValue();

             switch (op) {
             case Query.PLUS:
                 return new StringValueExp(sval1 + sval2);
             default:
                 throw new BadStringOperationException(opString());
             }
         }

         throw new BadBinaryOpValueExpException(this);
     }

     /**
      * Returns the string representing the object
      */
     public String toString()  {
         try {
             return parens(exp1, true) + " " + opString() + " " + parens(exp2, false);
         } catch (BadBinaryOpValueExpException ex) {
             return "invalid expression";
         }
     }

     /*
      * Add parentheses to the given subexpression if necessary to
      * preserve meaning.  Suppose this BinaryOpValueExp is
      * Query.times(Query.plus(Query.attr("A"), Query.attr("B")), Query.attr("C")).
      * Then the original toString() logic would return A + B * C.
      * We check precedences in order to return (A + B) * C, which is the
      * meaning of the ValueExp.
      *
      * We need to add parentheses if the unparenthesized expression would
      * be parsed as a different ValueExp from the original.
      * We cannot omit parentheses even when mathematically
      * the result would be equivalent, because we do not know whether the
      * numeric values will be integer or floating-point.  Addition and
      * multiplication are associative for integers but not always for
      * floating-point.
      *
      * So the rule is that we omit parentheses if the ValueExp
      * is (A op1 B) op2 C and the precedence of op1 is greater than or
      * equal to that of op2; or if the ValueExp is A op1 (B op2 C) and
      * the precedence of op2 is greater than that of op1.  (There are two
      * precedences: that of * and / is greater than that of + and -.)
      * The case of (A op1 B) op2 (C op3 D) applies each rule in turn.
      *
      * The following examples show the rules in action.  On the left,
      * the original ValueExp.  On the right, the string representation.
      *
      * (A + B) + C     A + B + C
      * (A * B) + C     A * B + C
      * (A + B) * C     (A + B) * C
      * (A * B) * C     A * B * C
      * A + (B + C)     A + (B + C)
      * A + (B * C)     A + B * C
      * A * (B + C)     A * (B + C)
      * A * (B * C)     A * (B * C)
      */
     private String parens(ValueExp subexp, boolean left)
     throws BadBinaryOpValueExpException {
         boolean omit;
         if (subexp instanceof BinaryOpValueExp) {
             int subop = ((BinaryOpValueExp) subexp).op;
             if (left)
                 omit = (precedence(subop) >= precedence(op));
             else
                 omit = (precedence(subop) > precedence(op));
         } else
             omit = true;

         if (omit)
             return subexp.toString();
         else
             return "(" + subexp + ")";
     }

     private int precedence(int xop) throws BadBinaryOpValueExpException {
         switch (xop) {
             case Query.PLUS: case Query.MINUS: return 0;
             case Query.TIMES: case Query.DIV: return 1;
             default:
                 throw new BadBinaryOpValueExpException(this);
         }
     }

     private String opString() throws BadBinaryOpValueExpException {
         switch (op) {
         case Query.PLUS:
             return "+";
         case Query.TIMES:
             return "*";
         case Query.MINUS:
             return "-";
         case Query.DIV:
             return "/";
         }

         throw new BadBinaryOpValueExpException(this);
     }

     @Deprecated
     public void setMBeanServer(MBeanServer s) {
         super.setMBeanServer(s);
      }
  }
	/*
	* Copyright (c) 1999, 2008, Oracle and/or its affiliates. All rights reserved.
	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	*
	* This code is free software; you can redistribute it and/or modify it
	* under the terms of the GNU General Public License version 2 only, as
	* published by the Free Software Foundation. Oracle designates this
	* particular file as subject to the "Classpath" exception as provided
	* by Oracle in the LICENSE file that accompanied this code.
	*
	* This code 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
	* version 2 for more details (a copy is included in the LICENSE file that
	* accompanied this code).
	*
	* You should have received a copy of the GNU General Public License version
	* 2 along with this work; if not, write to the Free Software Foundation,
	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	*
	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	* or visit www.oracle.com if you need additional information or have any
	* questions.
	*/

	package javax.management;


	/**
	* This class is used by the query-building mechanism to represent binary
	* operations.
	* @serial include
	*
	* @since 1.5
	*/
	class BinaryOpValueExp extends QueryEval implements ValueExp {

	/* Serial version */
	private static final long serialVersionUID = 1216286847881456786L;

	/**
	* @serial The operator
	*/
	private int op;

	/**
	* @serial The first value
	*/
	private ValueExp exp1;

	/**
	* @serial The second value
	*/
	private ValueExp exp2;


	/**
	* Basic Constructor.
	*/
	public BinaryOpValueExp() {
	}

	/**
	* Creates a new BinaryOpValueExp using operator o applied on v1 and
	* v2 values.
	*/
	public BinaryOpValueExp(int o, ValueExp v1, ValueExp v2) {
	op = o;
	exp1 = v1;
	exp2 = v2;
	}


	/**
	* Returns the operator of the value expression.
	*/
	public int getOperator() {
	return op;
	}

	/**
	* Returns the left value of the value expression.
	*/
	public ValueExp getLeftValue() {
	return exp1;
	}

	/**
	* Returns the right value of the value expression.
	*/
	public ValueExp getRightValue() {
	return exp2;
	}

	/**
	* Applies the BinaryOpValueExp on a MBean.
	*
	* @param name The name of the MBean on which the BinaryOpValueExp will be applied.
	*
	* @return The ValueExp.
	*
	* @exception BadStringOperationException
	* @exception BadBinaryOpValueExpException
	* @exception BadAttributeValueExpException
	* @exception InvalidApplicationException
	*/
	public ValueExp apply(ObjectName name) throws BadStringOperationException, BadBinaryOpValueExpException,
	BadAttributeValueExpException, InvalidApplicationException {
	ValueExp val1 = exp1.apply(name);
	ValueExp val2 = exp2.apply(name);
	String sval1;
	String sval2;
	double dval1;
	double dval2;
	long lval1;
	long lval2;
	boolean numeric = val1 instanceof NumericValueExp;

	if (numeric) {
	if (((NumericValueExp)val1).isLong()) {
	lval1 = ((NumericValueExp)val1).longValue();
	lval2 = ((NumericValueExp)val2).longValue();

	switch (op) {
	case Query.PLUS:
	return Query.value(lval1 + lval2);
	case Query.TIMES:
	return Query.value(lval1 * lval2);
	case Query.MINUS:
	return Query.value(lval1 - lval2);
	case Query.DIV:
	return Query.value(lval1 / lval2);
	}

	} else {
	dval1 = ((NumericValueExp)val1).doubleValue();
	dval2 = ((NumericValueExp)val2).doubleValue();

	switch (op) {
	case Query.PLUS:
	return Query.value(dval1 + dval2);
	case Query.TIMES:
	return Query.value(dval1 * dval2);
	case Query.MINUS:
	return Query.value(dval1 - dval2);
	case Query.DIV:
	return Query.value(dval1 / dval2);
	}
	}
	} else {
	sval1 = ((StringValueExp)val1).getValue();
	sval2 = ((StringValueExp)val2).getValue();

	switch (op) {
	case Query.PLUS:
	return new StringValueExp(sval1 + sval2);
	default:
	throw new BadStringOperationException(opString());
	}
	}

	throw new BadBinaryOpValueExpException(this);
	}

	/**
	* Returns the string representing the object
	*/
	public String toString() {
	try {
	return parens(exp1, true) + " " + opString() + " " + parens(exp2, false);
	} catch (BadBinaryOpValueExpException ex) {
	return "invalid expression";
	}
	}

	/*
	* Add parentheses to the given subexpression if necessary to
	* preserve meaning. Suppose this BinaryOpValueExp is
	* Query.times(Query.plus(Query.attr("A"), Query.attr("B")), Query.attr("C")).
	* Then the original toString() logic would return A + B * C.
	* We check precedences in order to return (A + B) * C, which is the
	* meaning of the ValueExp.
	*
	* We need to add parentheses if the unparenthesized expression would
	* be parsed as a different ValueExp from the original.
	* We cannot omit parentheses even when mathematically
	* the result would be equivalent, because we do not know whether the
	* numeric values will be integer or floating-point. Addition and
	* multiplication are associative for integers but not always for
	* floating-point.
	*
	* So the rule is that we omit parentheses if the ValueExp
	* is (A op1 B) op2 C and the precedence of op1 is greater than or
	* equal to that of op2; or if the ValueExp is A op1 (B op2 C) and
	* the precedence of op2 is greater than that of op1. (There are two
	* precedences: that of * and / is greater than that of + and -.)
	* The case of (A op1 B) op2 (C op3 D) applies each rule in turn.
	*
	* The following examples show the rules in action. On the left,
	* the original ValueExp. On the right, the string representation.
	*
	* (A + B) + C A + B + C
	* (A * B) + C A * B + C
	* (A + B) * C (A + B) * C
	* (A * B) * C A * B * C
	* A + (B + C) A + (B + C)
	* A + (B * C) A + B * C
	* A * (B + C) A * (B + C)
	* A * (B * C) A * (B * C)
	*/
	private String parens(ValueExp subexp, boolean left)
	throws BadBinaryOpValueExpException {
	boolean omit;
	if (subexp instanceof BinaryOpValueExp) {
	int subop = ((BinaryOpValueExp) subexp).op;
	if (left)
	omit = (precedence(subop) >= precedence(op));
	else
	omit = (precedence(subop) > precedence(op));
	} else
	omit = true;

	if (omit)
	return subexp.toString();
	else
	return "(" + subexp + ")";
	}

	private int precedence(int xop) throws BadBinaryOpValueExpException {
	switch (xop) {
	case Query.PLUS: case Query.MINUS: return 0;
	case Query.TIMES: case Query.DIV: return 1;
	default:
	throw new BadBinaryOpValueExpException(this);
	}
	}

	private String opString() throws BadBinaryOpValueExpException {
	switch (op) {
	case Query.PLUS:
	return "+";
	case Query.TIMES:
	return "*";
	case Query.MINUS:
	return "-";
	case Query.DIV:
	return "/";
	}

	throw new BadBinaryOpValueExpException(this);
	}

	@Deprecated
	public void setMBeanServer(MBeanServer s) {
	super.setMBeanServer(s);
	}
	}