Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * 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.
  */
 
 package org.apache.el.lang;
 
 import static org.jboss.web.ELMessages.MESSAGES;
 
A helper class of Arithmetic defined by the EL Specification

Author(s):
Jacob Hookom [jacob@hookom.net]
Version:
$Id: ELArithmetic.java 1882 2011-12-06 15:27:15Z remy.maucherat@jboss.com $
 
 public abstract class ELArithmetic {
 
     public static final class BigDecimalDelegate extends ELArithmetic {
 
         @Override
         protected Number add(Number num0Number num1) {
             return ((BigDecimalnum0).add((BigDecimalnum1);
         }
 
         @Override
         protected Number coerce(Number num) {
             if (num instanceof BigDecimal)
                 return num;
             if (num instanceof BigInteger)
                 return new BigDecimal((BigIntegernum);
             return new BigDecimal(num.doubleValue());
         }
 
         @Override
         protected Number coerce(String str) {
             return new BigDecimal(str);
         }
 
         @Override
         protected Number divide(Number num0Number num1) {
             return ((BigDecimalnum0).divide((BigDecimalnum1,
                     .);
         }
 
         @Override
         protected Number subtract(Number num0Number num1) {
             return ((BigDecimalnum0).subtract((BigDecimalnum1);
         }
 
         @Override
         protected Number mod(Number num0Number num1) {
             return new Double(num0.doubleValue() % num1.doubleValue());
         }
 
         @Override
         protected Number multiply(Number num0Number num1) {
             return ((BigDecimalnum0).multiply((BigDecimalnum1);
         }
 
         @Override
         public boolean matches(Object obj0Object obj1) {
             return (obj0 instanceof BigDecimal || obj1 instanceof BigDecimal);
         }
     }
 
     public static final class BigIntegerDelegate extends ELArithmetic {
 
         @Override
         protected Number add(Number num0Number num1) {
             return ((BigIntegernum0).add((BigIntegernum1);
         }
 
         @Override
         protected Number coerce(Number num) {
             if (num instanceof BigInteger)
                 return num;
             return new BigInteger(num.toString());
         }
 
         @Override
         protected Number coerce(String str) {
             return new BigInteger(str);
         }
 
        @Override
        protected Number divide(Number num0Number num1) {
            return (new BigDecimal((BigIntegernum0)).divide(new BigDecimal((BigIntegernum1), .);
        }
        @Override
        protected Number multiply(Number num0Number num1) {
            return ((BigIntegernum0).multiply((BigIntegernum1);
        }
        @Override
        protected Number mod(Number num0Number num1) {
            return ((BigIntegernum0).mod((BigIntegernum1);
        }
        @Override
        protected Number subtract(Number num0Number num1) {
            return ((BigIntegernum0).subtract((BigIntegernum1);
        }
        @Override
        public boolean matches(Object obj0Object obj1) {
            return (obj0 instanceof BigInteger || obj1 instanceof BigInteger);
        }
    }
    public static final class DoubleDelegate extends ELArithmetic {
        @Override
        protected Number add(Number num0Number num1) {
            // could only be one of these
            if (num0 instanceof BigDecimal) {
                return ((BigDecimalnum0).add(new BigDecimal(num1.doubleValue()));
            } else if (num1 instanceof BigDecimal) {
                return ((new BigDecimal(num0.doubleValue()).add((BigDecimalnum1)));
            }
            return new Double(num0.doubleValue() + num1.doubleValue());
        }
        @Override
        protected Number coerce(Number num) {
            if (num instanceof Double)
                return num;
            if (num instanceof BigInteger)
                return new BigDecimal((BigIntegernum);
            return new Double(num.doubleValue());
        }
        @Override
        protected Number coerce(String str) {
            return new Double(str);
        }
        @Override
        protected Number divide(Number num0Number num1) {
            return new Double(num0.doubleValue() / num1.doubleValue());
        }
        @Override
        protected Number mod(Number num0Number num1) {
            return new Double(num0.doubleValue() % num1.doubleValue());
        }
        @Override
        protected Number subtract(Number num0Number num1) {
            // could only be one of these
            if (num0 instanceof BigDecimal) {
                return ((BigDecimalnum0).subtract(new BigDecimal(num1.doubleValue()));
            } else if (num1 instanceof BigDecimal) {
                return ((new BigDecimal(num0.doubleValue()).subtract((BigDecimalnum1)));
            }
            return new Double(num0.doubleValue() - num1.doubleValue());
        }
        @Override
        protected Number multiply(Number num0Number num1) {
            // could only be one of these
            if (num0 instanceof BigDecimal) {
                return ((BigDecimalnum0).multiply(new BigDecimal(num1.doubleValue()));
            } else if (num1 instanceof BigDecimal) {
                return ((new BigDecimal(num0.doubleValue()).multiply((BigDecimalnum1)));
            }
            return new Double(num0.doubleValue() * num1.doubleValue());
        }
        @Override
        public boolean matches(Object obj0Object obj1) {
            return (obj0 instanceof Double
                    || obj1 instanceof Double
                    || obj0 instanceof Float
                    || obj1 instanceof Float
                    || (obj0 instanceof String && ELSupport
                            .isStringFloat((Stringobj0)) || (obj1 instanceof String && ELSupport
                    .isStringFloat((Stringobj1)));
        }
    }
    public static final class LongDelegate extends ELArithmetic {
        @Override
        protected Number add(Number num0Number num1) {
            return Long.valueOf(num0.longValue() + num1.longValue());
        }
        @Override
        protected Number coerce(Number num) {
            if (num instanceof Long)
                return num;
            return Long.valueOf(num.longValue());
        }
        @Override
        protected Number coerce(String str) {
            return Long.valueOf(str);
        }
        @Override
        protected Number divide(Number num0Number num1) {
            return Long.valueOf(num0.longValue() / num1.longValue());
        }
        @Override
        protected Number mod(Number num0Number num1) {
            return Long.valueOf(num0.longValue() % num1.longValue());
        }
        @Override
        protected Number subtract(Number num0Number num1) {
            return Long.valueOf(num0.longValue() - num1.longValue());
        }
        @Override
        protected Number multiply(Number num0Number num1) {
            return Long.valueOf(num0.longValue() * num1.longValue());
        }
        @Override
        public boolean matches(Object obj0Object obj1) {
            return (obj0 instanceof Long || obj1 instanceof Long);
        }
    }
    public static final BigDecimalDelegate BIGDECIMAL = new BigDecimalDelegate();
    public static final BigIntegerDelegate BIGINTEGER = new BigIntegerDelegate();
    public static final DoubleDelegate DOUBLE = new DoubleDelegate();
    public static final LongDelegate LONG = new LongDelegate();
    private static final Long ZERO = Long.valueOf(0);
    public static final Number add(final Object obj0final Object obj1) {
        if (obj0 == null && obj1 == null) {
            return Long.valueOf(0);
        }
        final ELArithmetic delegate;
        if (.matches(obj0obj1))
            delegate = ;
        else if (.matches(obj0obj1)) {
            if (.matches(obj0obj1))
                delegate = ;
            else
                delegate = ;
        } else if (.matches(obj0obj1))
            delegate = ;
        else
            delegate = ;
        Number num0 = delegate.coerce(obj0);
        Number num1 = delegate.coerce(obj1);
        return delegate.add(num0num1);
    }
    public static final Number mod(final Object obj0final Object obj1) {
        if (obj0 == null && obj1 == null) {
            return Long.valueOf(0);
        }
        final ELArithmetic delegate;
        if (.matches(obj0obj1))
            delegate = ;
        else if (.matches(obj0obj1))
            delegate = ;
        else if (.matches(obj0obj1))
            delegate = ;
        else
            delegate = ;
        Number num0 = delegate.coerce(obj0);
        Number num1 = delegate.coerce(obj1);
        return delegate.mod(num0num1);
    }
    public static final Number subtract(final Object obj0final Object obj1) {
        if (obj0 == null && obj1 == null) {
            return Long.valueOf(0);
        }
        final ELArithmetic delegate;
        if (.matches(obj0obj1))
            delegate = ;
        else if (.matches(obj0obj1)) {
            if (.matches(obj0obj1))
                delegate = ;
            else
                delegate = ;
        } else if (.matches(obj0obj1))
            delegate = ;
        else
            delegate = ;
        Number num0 = delegate.coerce(obj0);
        Number num1 = delegate.coerce(obj1);
        return delegate.subtract(num0num1);
    }
    public static final Number divide(final Object obj0final Object obj1) {
        if (obj0 == null && obj1 == null) {
            return ;
        }
        final ELArithmetic delegate;
        if (.matches(obj0obj1))
            delegate = ;
        else if (.matches(obj0obj1))
            delegate = ;
        else
            delegate = ;
        Number num0 = delegate.coerce(obj0);
        Number num1 = delegate.coerce(obj1);
        return delegate.divide(num0num1);
    }
    public static final Number multiply(final Object obj0final Object obj1) {
        if (obj0 == null && obj1 == null) {
            return Long.valueOf(0);
        }
        final ELArithmetic delegate;
        if (.matches(obj0obj1))
            delegate = ;
        else if (.matches(obj0obj1)) {
            if (.matches(obj0obj1))
                delegate = ;
            else
                delegate = ;
        } else if (.matches(obj0obj1))
            delegate = ;
        else
            delegate = ;
        Number num0 = delegate.coerce(obj0);
        Number num1 = delegate.coerce(obj1);
        return delegate.multiply(num0num1);
    }
    public static final boolean isNumber(final Object obj) {
        return (obj != null && isNumberType(obj.getClass()));
    }
    public static final boolean isNumberType(final Class<?> type) {
        return type == . || type == . ||
            type == . || type == . ||
            type == . || type == . ||
            Number.class.isAssignableFrom(type);
    }

    
    protected ELArithmetic() {
        super();
    }
    protected abstract Number add(final Number num0final Number num1);
    protected abstract Number multiply(final Number num0final Number num1);
    protected abstract Number subtract(final Number num0final Number num1);
    protected abstract Number mod(final Number num0final Number num1);
    protected abstract Number coerce(final Number num);
    protected final Number coerce(final Object obj) {
        if (isNumber(obj)) {
            return coerce((Numberobj);
        }
        if (obj == null || "".equals(obj)) {
            return coerce();
        }
        if (obj instanceof String) {
            return coerce((Stringobj);
        }
        if (obj instanceof Character) {
            return coerce(Short.valueOf((short) ((Characterobj).charValue()));
        }
        throw .errorConvertingWithException(objobj.getClass(), "Number");
    }
    protected abstract Number coerce(final String str);
    protected abstract Number divide(final Number num0final Number num1);
    protected abstract boolean matches(final Object obj0final Object obj1);
New to GrepCode? Check out our FAQ X