src/main/java/org/apache/commons/ognl/NumericExpression.java

package org.apache.commons.ognl;

/*
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 *
 *   http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 */

import org.apache.commons.ognl.enhance.ExpressionCompiler;

/**
 * Base class for numeric expressions.
 */
public abstract class NumericExpression
    extends ExpressionNode
    implements NodeType
{

    private static final long serialVersionUID = -174952564587478850L;

    protected Class<?> getterClass;

    public NumericExpression( int id )
    {
        super( id );
    }

    public NumericExpression( OgnlParser p, int id )
    {
        super( p, id );
    }

    /**
     * {@inheritDoc}
     */
    public Class<?> getGetterClass()
    {
        if ( getterClass != null )
        {
            return getterClass;
        }

        return Double.TYPE;
    }

    /**
     * {@inheritDoc}
     */
    public Class<?> getSetterClass()
    {
        return null;
    }

    /**
     * {@inheritDoc}
     */
    @Override
    public String toGetSourceString( OgnlContext context, Object target )
    {
        Object value;
        StringBuilder result = new StringBuilder( "" );

        try
        {

            value = getValueBody( context, target );

            if ( value != null )
            {
                getterClass = value.getClass();
            }

            for ( int i = 0; i < children.length; i++ )
            {
                if ( i > 0 )
                {
                    result.append( " " ).append( getExpressionOperator( i ) ).append( " " );
                }
                String str = OgnlRuntime.getChildSource( context, target, children[i] );

                result.append( coerceToNumeric( str, context, children[i] ) );
            }

        }
        catch ( Throwable t )
        {
            throw OgnlOps.castToRuntime( t );
        }

        return result.toString();
    }

    public String coerceToNumeric( String source, OgnlContext context, Node child )
    {
        StringBuilder ret = new StringBuilder( source );
        Object value = context.getCurrentObject();

        if ( ASTConst.class.isInstance( child ) && value != null )
        {
            return value.toString();
        }

        if ( context.getCurrentType() != null && !context.getCurrentType().isPrimitive()
            && context.getCurrentObject() != null && Number.class.isInstance( context.getCurrentObject() ) )
        {
            ret = new StringBuilder( "((" ).append(
                ExpressionCompiler.getCastString( context.getCurrentObject().getClass() ) ).append( ")" ).append(
                ret ).append( ")." ).append(
                OgnlRuntime.getNumericValueGetter( context.getCurrentObject().getClass() ) );
        }
        else if ( context.getCurrentType() != null && context.getCurrentType().isPrimitive()
            && ( ASTConst.class.isInstance( child ) || NumericExpression.class.isInstance( child ) ) )
        {
            @SuppressWarnings( "unchecked" ) // checked by the condition in the if clause
            Class<? extends Number> numberClass = (Class<? extends Number>) context.getCurrentType();
            ret.append( OgnlRuntime.getNumericLiteral( numberClass ) );
        }
        else if ( context.getCurrentType() != null && String.class.isAssignableFrom( context.getCurrentType() ) )
        {
            ret = new StringBuilder( "Double.parseDouble(" )
                .append( ret )
                .append( ")" );
            context.setCurrentType( Double.TYPE );
        }

        if ( NumericExpression.class.isInstance( child ) )
        {
            ret = new StringBuilder( "(" ).append( ret ).append( ")" );
        }

        return ret.toString();
    }
}