Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  package com.cantaa.util.type;
  
General class to represent a number. Internally a BigDecimal is used.

Author(s):
Hans Lesmeister
 
 public abstract class Amount<T extends Amount<T>> extends Number implements Serializable
 {
    private BigDecimal value;
 
    protected Amount(BigDecimal valueint decimalPlaces)
    {
       if (decimalPlaces < 0) {
          decimalPlaces = 0;
       }
 
       if (value == null) {
          value = new BigDecimal(0);
       }
 
       this. = value;
       this. = value.setScale(decimalPlaces.);
    }
 
    protected Amount(BigDecimal value)
    {
       this(value, 0);
    }
 
    public BigDecimal getValue()
    {
       return ;
    }

   
Subtract an amount from this Amount

Parameters:
amount Amount to subtract. If null, zero is subtracted
Returns:
The new amount
See also:
java.math.BigDecimal.subtract(java.math.BigDecimal)
 
    public T subtract(Amount<T> amount) {
 
       BigDecimal newValue = ;
 
       if (amount != null) {
          newValue = .subtract(amount.getValue());
       }
 
       return createInstance(newValue);
    }

   

Returns:
true if the Amount is negative, i.e. smaller than zero
 
    public boolean isNegative() {
       return .signum() < 0;
    }

   

Returns:
true if the Amount is positive, i.e. greater than zero
 
    public boolean isPositive() {
       return .signum() > 0;
    }

   
Add an amount to this Amount

Parameters:
amount Amount to add. If null, zero is added
Returns:
The new amount
See also:
java.math.BigDecimal.add(java.math.BigDecimal)
 
    public T add(Amount<T> amount)
    {
       BigDecimal newValue = ;
 
       if (amount != null) {
          newValue = .add(amount.getValue());
       }
 
       return createInstance(newValue);
    }
 
 
    public T divideBy(Amount<T> amount)
    {
       BigDecimal newValue = ;
 
       if (amount != null) {
          newValue = .divide(amount.getValue(), getValue().scale(), .);
       }
 
       return createInstance(newValue);
    }
   public T divideBy(int amount)
   {
      return divideBy(createInstance(new BigDecimal(amount)));
   }
   public T multiplyWith(Amount<?> amount)
   {
      BigDecimal newValue = ;
      if (amount != null) {
         newValue = .multiply(amount.getValue());
      }
      return createInstance(newValue);
   }
   @SuppressWarnings({"unchecked""rawtypes"})
   public final T createInstance(BigDecimal amount) {
      try {
         Constructor c = this.getClass().getConstructor(BigDecimal.class);
         T result = (T) c.newInstance(amount);
         return result;
      }
      catch (InstantiationException e) {
         throw new RuntimeException(e);
      }
      catch (IllegalAccessException e) {
         throw new RuntimeException(e);
      }
      catch (NoSuchMethodException e) {
         throw new RuntimeException(e);
      }
      catch (InvocationTargetException e) {
         throw new RuntimeException(e);
      }
   }
   @SuppressWarnings("unchecked")
   public boolean equals(Object o)
   {
      if (this == o) {
         return true;
      }
      if (o == null || getClass() != o.getClass()) {
         return false;
      }
      Amount<T> amount = (Amount<T>) o;
      return .equals(amount.value);
   }
   public int hashCode()
   {
      return .hashCode();
   }
   public String toString()
   {
      return .toString();
   }
    @Override
    public int intValue() {
        return .intValue();
    }
    @Override
    public long longValue() {
        return .longValue();
    }
    @Override
    public float floatValue() {
        return .floatValue();
    }
    @Override
    public double doubleValue() {
        return .doubleValue();
    }
New to GrepCode? Check out our FAQ X