/*******************************************************************************
* Copyright (c) 2006 Oracle Corporation.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* Cameron Bateman/Oracle - initial API and implementation
*
********************************************************************************/
package org.eclipse.jst.jsf.validation.internal.el.operators;
import java.math.BigDecimal;
import org.eclipse.emf.common.util.Diagnostic;
import org.eclipse.jdt.core.Signature;
import org.eclipse.jst.jsf.common.internal.types.FloatLiteralType;
import org.eclipse.jst.jsf.common.internal.types.IAssignable;
import org.eclipse.jst.jsf.common.internal.types.IntegerLiteralType;
import org.eclipse.jst.jsf.common.internal.types.LiteralType;
import org.eclipse.jst.jsf.common.internal.types.TypeCoercer;
import org.eclipse.jst.jsf.common.internal.types.TypeCoercionException;
import org.eclipse.jst.jsf.common.internal.types.TypeConstants;
import org.eclipse.jst.jsf.common.internal.types.TypeTransformer;
import org.eclipse.jst.jsf.common.internal.types.ValueType;
import org.eclipse.jst.jsf.validation.internal.el.diagnostics.DiagnosticFactory;
/**
* Represents dividing EL binary operators: div and / (same operator)
* Based on JSP.2.3.5.2
*
* @author cbateman
*
*/
/*package*/ class DivArithmeticBinaryOperator extends ArithmeticBinaryOperator
{
private static final String DIVISION = "division"; //$NON-NLS-1$
DivArithmeticBinaryOperator(DiagnosticFactory diagnosticFactory) {
super(diagnosticFactory);
// TODO Auto-generated constructor stub
}
public ValueType performOperation(ValueType firstArg, ValueType secondArg)
{
// JSP.2.3.5.2, step one: if both null then always 0
if (TypeCoercer.typeIsNull(firstArg.getSignature())
&& TypeCoercer.typeIsNull(secondArg.getSignature()))
{
return new IntegerLiteralType(0);
}
final String boxedFirstArg = TypeTransformer.transformBoxPrimitives(firstArg.getSignature());
final String boxedSecondArg = TypeTransformer.transformBoxPrimitives(secondArg.getSignature());
// JSP.2.3.5.2, step 2: if one arg is BigInteger or BigDecimal
// then coerce to BigDecimal and do div
if (TypeConstants.TYPE_BIG_DOUBLE.equals(boxedFirstArg)
|| TypeConstants.TYPE_BIG_DOUBLE.equals(boxedSecondArg)
|| TypeConstants.TYPE_BIG_INTEGER.equals(boxedFirstArg)
|| TypeConstants.TYPE_BIG_INTEGER.equals(boxedSecondArg))
{
return performBigDecimal(firstArg, secondArg);
}
return performDouble(firstArg, secondArg);
}
public Diagnostic validate(ValueType firstArg, ValueType secondArg) {
if (TypeConstants.TYPE_JAVAOBJECT.equals(firstArg.getSignature()) ||
TypeConstants.TYPE_JAVAOBJECT.equals(secondArg.getSignature())) {
return Diagnostic.OK_INSTANCE;
}
// JSP.2.3.5.2, step one: if both null then always 0
if (TypeCoercer.typeIsNull(firstArg.getSignature())
&& TypeCoercer.typeIsNull(secondArg.getSignature()))
{
return _diagnosticFactory.create_BINARY_OP_BOTH_OPERANDS_NULL(DIVISION);
}
final String boxedFirstArg = TypeTransformer.transformBoxPrimitives(firstArg.getSignature());
final String boxedSecondArg = TypeTransformer.transformBoxPrimitives(secondArg.getSignature());
// JSP.2.3.5.2, step 2: if one arg is BigInteger or BigDecimal
// then coerce to BigDecimal and do div
if (TypeConstants.TYPE_BIG_DOUBLE.equals(boxedFirstArg)
|| TypeConstants.TYPE_BIG_DOUBLE.equals(boxedSecondArg)
|| TypeConstants.TYPE_BIG_INTEGER.equals(boxedFirstArg)
|| TypeConstants.TYPE_BIG_INTEGER.equals(boxedSecondArg))
{
return validateBigDecimal(firstArg, secondArg);
}
return validateDouble(firstArg, secondArg);
}
private ValueType performBigDecimal(ValueType firstArg, ValueType secondArg)
{
// since one or the other args must be either big decimal or big int,
// we don't have two literals, so it is sufficient to ensure that we can
// coerce both to numbers and check for div by zero and div of zero
try
{
TypeCoercer.coerceToNumber(TypeTransformer.transformBoxPrimitives(firstArg.getSignature()));
TypeCoercer.coerceToNumber(TypeTransformer.transformBoxPrimitives(secondArg.getSignature()));
// if we get to here, the result is always BigDecimal unless we have
// a div by zero
if (secondArg instanceof LiteralType)
{
final Number coercedValue = ((LiteralType)secondArg).coerceToNumber(BigDecimal.class);
if (((BigDecimal)coercedValue).equals(new BigDecimal(0)))
{
return null;
}
}
return new ValueType(TypeConstants.TYPE_BIG_DOUBLE, IAssignable.ASSIGNMENT_TYPE_RHS);
}
catch (TypeCoercionException ce)
{
return null;
}
}
private ValueType performDouble(ValueType firstArg, ValueType secondArg)
{
try
{
TypeCoercer.coerceToNumber(TypeTransformer.transformBoxPrimitives(firstArg.getSignature()));
TypeCoercer.coerceToNumber(TypeTransformer.transformBoxPrimitives(secondArg.getSignature()));
Number secondValue = null;
if (secondArg instanceof LiteralType)
{
secondValue = ((LiteralType)secondArg).coerceToNumber(Double.class);
// if the second value is definitely 0, then return null since
// we have a div by zero
if (secondValue.doubleValue() == 0.0)
{
return null;
}
}
Number firstValue = null;
if (firstArg instanceof LiteralType)
{
firstValue = ((LiteralType)firstArg).coerceToNumber(Double.class);
}
if (firstValue != null && secondValue != null)
{
return new FloatLiteralType(
doRealOperation(new Double(firstValue.doubleValue())
, new Double(secondValue.doubleValue())).doubleValue());
}
// if not both literals and could coerce, then the type is double
return new ValueType(Signature.SIG_DOUBLE, IAssignable.ASSIGNMENT_TYPE_RHS);
}
catch (TypeCoercionException ce)
{
// could not coerce for the operation
return null;
}
}
private Diagnostic validateBigDecimal(ValueType firstArg, ValueType secondArg)
{
// since one or the other args must be either big decimal or big int,
// we don't have two literals, so it is sufficient to ensure that we can
// coerce both to numbers and check for div by zero and div of zero
try
{
TypeCoercer.coerceToNumber(TypeTransformer.transformBoxPrimitives(firstArg.getSignature()));
TypeCoercer.coerceToNumber(TypeTransformer.transformBoxPrimitives(secondArg.getSignature()));
// if we get to here, the result is always BigDecimal unless we have
// a div by zero
if (secondArg instanceof LiteralType)
{
final Number coercedValue = ((LiteralType)secondArg).coerceToNumber(BigDecimal.class);
if (((BigDecimal)coercedValue).equals(new BigDecimal(0)))
{
return _diagnosticFactory.create_BINARY_OP_POSSIBLE_DIVISION_BY_ZERO();
}
}
// everything's okay if we get here
return Diagnostic.OK_INSTANCE;
}
catch (TypeCoercionException ce)
{
return _diagnosticFactory.create_BINARY_OP_COULD_NOT_MAKE_NUMERIC_COERCION(DIVISION);
}
}
private Diagnostic validateDouble(ValueType firstArg, ValueType secondArg)
{
try
{
TypeCoercer.coerceToNumber(TypeTransformer.transformBoxPrimitives(firstArg.getSignature()));
TypeCoercer.coerceToNumber(TypeTransformer.transformBoxPrimitives(secondArg.getSignature()));
Number secondValue = null;
if (secondArg instanceof LiteralType)
{
secondValue = ((LiteralType)secondArg).coerceToNumber(Double.class);
// if the second value is definitely 0, then return null since
// we have a div by zero
if (secondValue.doubleValue() == 0.0)
{
return _diagnosticFactory.create_BINARY_OP_POSSIBLE_DIVISION_BY_ZERO();
}
}
Number firstValue = null;
if (firstArg instanceof LiteralType)
{
firstValue = ((LiteralType)firstArg).coerceToNumber(Double.class);
}
if (firstValue != null && secondValue != null)
{
String result
= Double.toString(
doRealOperation(new Double(firstValue.doubleValue()),
new Double(secondValue.doubleValue())).doubleValue());
return _diagnosticFactory.create_BINARY_OP_CONSTANT_EXPRESSION_ALWAYS_EVAL_SAME(DIVISION, result);
}
// if not both literals and could coerce, then the type is double
return Diagnostic.OK_INSTANCE;
}
catch (TypeCoercionException ce)
{
// could not coerce for the operation
return _diagnosticFactory.create_BINARY_OP_COULD_NOT_MAKE_NUMERIC_COERCION(DIVISION);
}
}
protected BigDecimal doRealOperation(BigDecimal firstArg, BigDecimal secondArg) {
// per JSP.2.3.5.2, step 2
return firstArg.divide(secondArg, BigDecimal.ROUND_HALF_UP);
}
protected Double doRealOperation(Double firstArg, Double secondArg)
{
return new Double(firstArg.doubleValue() / secondArg.doubleValue());
}
protected Long doRealOperation(Long firstArg, Long secondArg) {
return Long.valueOf(firstArg.longValue() / secondArg.longValue());
}
protected String getOperatorName() {
return DIVISION;
}
}