Money (hybris Commerce Suite 6.3.0.0-SNAPSHOT)

java.lang.Object
- de.hybris.order.calculation.money.AbstractAmount
- - de.hybris.order.calculation.money.Money

public class Money
extends AbstractAmount

Represents a monetary amount by combining a BigDecimal and a Currency. Please know that the scale of the amount is always equal to the amount of currency digits.Therefore the following rules apply:

used values		result
BigDecimal	Currency.getDigits()	Money.getAmount() as BigDecimal
new BigDecimal(1.000)	0	1
new BigDecimal(1.000)	3	1.000
BigDecimal.ZERO	2	0.00
BigDecimal.valueOf(-1.34)	3	-1.340
BigDecimal.valueOf(1.234)	1	1.2 since we simply cut off the extra digits

This class provides common operations like add(Money), subtract(Money) and split(List).

A Money in the smallest amount (example 0.01 EUR) can not be split in smaller amounts. Splitting this amount in two will return {0.01 EUR, 0.00 EUR}.

Last but not least there are a number of tool methods to ease working with this class: zero(Currency), valueOf(Currency, String...), sum(Collection), sortAscending(List) and getPercentages(Money...) to name a few.

Nested Class Summary

Nested Classes
Modifier and Type Class and Description

static interface Money.MoneyExtractor<T>

Nested Classes
Modifier and Type	Class and Description
`static interface`	`Money.MoneyExtractor<T>`

Constructor Summary

Constructors
Constructor and Description
`Money(BigDecimal amount, Currency currency)` Creates a Money object.
`Money(Currency currency)` Creates zero money of the given Currency.
`Money(long amountInSmallestPieces, Currency currency)` Creates a new money from a given amount of smallest pieces and a currency.
`Money(String amount, Currency currency)` Creates a new money from String and currency.

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`Money`	`add(Money money)` Add to the current `Money` amount the given `Money` amount.
`void`	`assertCurreniesAreEqual(Currency curr)` Checks if the current Currency is equal to given one.
`void`	`assertCurreniesAreEqual(Money other)` Checks if the current Currency is equal to given one.
`protected BigDecimal`	`checkPercentages(List<Percentage> percentages)`
`boolean`	`equals(Object obj)` Returns true if the given parameter is also an instanceof money and the current currency is equal to the currency of the given money and the current amount is comparedTo == 0 to the given money amount.
`BigDecimal`	`getAmount()` The monetary amount.
`Currency`	`getCurrency()` Returns the currency of this money.
`static List<Percentage>`	`getPercentages(int scale, Money... moneys)` Calculates a list of `Percentage` objects reflecting the distribution of money within the given money list.
`static List<Percentage>`	`getPercentages(List<Money> moneys, int scale)` Calculates a list of `Percentage` objects reflecting the distribution of money within the given money list.
`static List<Percentage>`	`getPercentages(Money... moneys)` Calculates a list of `Percentage` objects reflecting the distribution of money within the given money list.
`protected static int[]`	`getSortedPositionTable(List<Money> moneyList)`
`int`	`hashCode()`
`static void`	`sortAscending(List<Money> elements)`
`protected static <T> List<T>`	`sortByMoney(Map<T,Money> moneyMap, Comparator<Map.Entry<?,Money>> comp)`
`static <T> List<T>`	`sortByMoneyAscending(Map<T,Money> moneyMap)`
`static <T> List<T>`	`sortByMoneyDescending(Map<T,Money> moneyMap)`
`static void`	`sortDescending(List<Money> elements)`
`List<Money>`	`split(List<Percentage> percentages)` Splits the current Money into a list of new Money objects, based on the given list of `Percentage` objects.
`List<Money>`	`split(Percentage... percentages)` Same as `split(List)` but because of the variable parameter list the sum must not be exactly 100%.
`Money`	`subtract(Money money)` Subtracts from current `Money` amount the given `Money` amount.
`static Money`	`sum(Collection<Money> elements)`
`static <T> Money`	`sum(Collection<T> elements, Money.MoneyExtractor<T> extractor)`
`static Money`	`sum(Money... money)`
`protected static long`	`sumUnscaled(Collection<Money> elements)`
`protected static <T> Money`	`sumUnscaled(Collection<T> elements, Money.MoneyExtractor<T> extractor)`
`String`	`toString()` Returns the amount of the value formatted with the `Currency.getDigits()` and the currency isocode.
`static List<Money>`	`valueOf(Currency curr, BigDecimal... amounts)` Creates a list of money objects for a specific currency and any number of BigDecimal values.
`static List<Money>`	`valueOf(Currency curr, long... amounts)` Creates a list of money objects for a specific currency and any number of long values.
`static List<Money>`	`valueOf(Currency curr, String... amounts)` Creates a list of money objects for a specific currency and any number of String values.
`static Money`	`zero(Currency curr)` Shortcut to obtain commonly used zero money instances.

Methods inherited from class java.lang.Object
clone, finalize, getClass, notify, notifyAll, wait, wait, wait

- Constructor Detail
  - Money
```
public Money(BigDecimal amount,
             Currency currency)
```
    Creates a Money object. A new BigDecimal object is used internally, based on Currency.getDigits().
    amount and this.getAmount() are maybe not equal (because of the different scale of the BigDecimal) BUT new Money(BigDecimal.ONE, curr) and new Money(new BigDecimal("1.000"), curr) are equal with each other!
    
    Parameters:
    
    amount - the value or amount of the money
    
    currency - the amount of the money in the hybris Currency pojo
    
    Throws:
    
    ArithmeticException - if the amount must be rounded because the Currency.getDigits() does not provide enough digits.
  - Money
```
public Money(Currency currency)
```
    Creates zero money of the given Currency.
    
    Parameters:
    
    currency -
  - Money
```
public Money(long amountInSmallestPieces,
             Currency currency)
```
    Creates a new money from a given amount of smallest pieces and a currency.
  - Money
```
public Money(String amount,
             Currency currency)
```
    Creates a new money from String and currency.
- Method Detail
  - valueOf
```
public static List<Money> valueOf(Currency curr,
                                  String... amounts)
```
    Creates a list of money objects for a specific currency and any number of String values.
  - valueOf
```
public static List<Money> valueOf(Currency curr,
                                  long... amounts)
```
    Creates a list of money objects for a specific currency and any number of long values.
  - valueOf
```
public static List<Money> valueOf(Currency curr,
                                  BigDecimal... amounts)
```
    Creates a list of money objects for a specific currency and any number of BigDecimal values.
  - zero
```
public static Money zero(Currency curr)
```
    Shortcut to obtain commonly used zero money instances. Since they are cached this methods should be preferred to Money(Currency).
  - getCurrency
```
public Currency getCurrency()
```
    Returns the currency of this money.
  - getAmount
```
public BigDecimal getAmount()
```
    The monetary amount. The amount scale is equal to the currency digits!
  - assertCurreniesAreEqual
```
public void assertCurreniesAreEqual(Currency curr)
```
    Checks if the current Currency is equal to given one.
    
    Throws:
    
    CurrenciesAreNotEqualException - if the currencies are not equal.
  - assertCurreniesAreEqual
```
public void assertCurreniesAreEqual(Money other)
```
    Checks if the current Currency is equal to given one.
    
    Throws:
    
    CurrenciesAreNotEqualException - if the currencies are not equal.
  - add
```
public Money add(Money money)
```
    Add to the current Money amount the given Money amount. The result is a new Money object with the sum of both amounts and in the same currency.
    
    Parameters:
    
    money - this will be added to the current money amount
    
    Returns:
    
    a new object with the sum
    
    Throws:
    
    CurrenciesAreNotEqualException - if getCurrency() is different in the given objects
  - subtract
```
public Money subtract(Money money)
```
    Subtracts from current Money amount the given Money amount. The result is a new Money object with the difference of both amounts and in the same currency.
    
    Parameters:
    
    money - this will be subtracted to the current money amount
    
    Returns:
    
    a new object with the difference
    
    Throws:
    
    CurrenciesAreNotEqualException - if getCurrency() is different in the given objects
  - hashCode
```
public int hashCode()
```
    Overrides:
    
    hashCode in class Object
    
    Returns:
    
    currency.hashCode + amount.hashCode
  - equals
```
public boolean equals(Object obj)
```
    Returns true if the given parameter is also an instanceof money and the current currency is equal to the currency of the given money and the current amount is comparedTo == 0 to the given money amount. (this is not BigDecimal.equals(BigDecimal), the check is BigDecimal.compareTo(BigDecimal))
    
    Overrides:
    
    equals in class Object
  - toString
```
public String toString()
```
    Returns the amount of the value formatted with the Currency.getDigits() and the currency isocode. Example: "1.20 EUR"
    
    Overrides:
    
    toString in class AbstractAmount
    
    Returns:
    
    {0.xx} {currency.toString};
    xx.lenght == currency.digits
  - split
```
public List<Money> split(Percentage... percentages)
```
    Same as split(List) but because of the variable parameter list the sum must not be exactly 100%. If less the missing Percentage value will be added. This means, the size of the resulting list is equal to the given percentage list if the sum of them is exactly 100% or the size of the resulting list is one more if the given percentage list is less than 100%. Anyway a CalculationException is thrown if the sum is greater than 100%.
    
    Parameters:
    
    percentages - the variable list of percentages
    
    Returns:
    
    a List of Money objects which are summed up the same amount of this current Money object.
  - split
```
public List<Money> split(List<Percentage> percentages)
```
    Splits the current Money into a list of new Money objects, based on the given list of Percentage objects. The sum of the Percentages must be equal to 100% or a CalculationException is thrown. The size of the returned money list is equal to the size of the given percentage list. The sum of the returned money list is equal to the given amount of money. A money can only be split into the smallest possible amount of this money which depends on the currency. If a small amount of money can not be split anymore this amount is added to the last entry in the returned list.
    Example: splitting 0.01 EURO into half results in [0.00EUR , 0.01EUR]
    
    Parameters:
    
    percentages - the list of Percentage in which the current money should be split into.
    
    Returns:
    
    a List of Money objects which are summed up the same amount of this current Money object.
    
    Throws:
    
    AmountException - if the sum of the percentages is not 100%
    
    IllegalArgumentException - if the percent list is null or empty
  - checkPercentages
```
protected BigDecimal checkPercentages(List<Percentage> percentages)
```
  - sortByMoneyAscending
```
public static <T> List<T> sortByMoneyAscending(Map<T,Money> moneyMap)
```
  - sortByMoney
```
protected static <T> List<T> sortByMoney(Map<T,Money> moneyMap,
                                         Comparator<Map.Entry<?,Money>> comp)
```
  - sortByMoneyDescending
```
public static <T> List<T> sortByMoneyDescending(Map<T,Money> moneyMap)
```
  - sortAscending
```
public static void sortAscending(List<Money> elements)
```
  - sortDescending
```
public static void sortDescending(List<Money> elements)
```
  - sum
```
public static final <T> Money sum(Collection<T> elements,
                                  Money.MoneyExtractor<T> extractor)
```
  - sum
```
public static final Money sum(Money... money)
```
  - sum
```
public static final Money sum(Collection<Money> elements)
```
  - sumUnscaled
```
protected static final <T> Money sumUnscaled(Collection<T> elements,
                                             Money.MoneyExtractor<T> extractor)
```
  - sumUnscaled
```
protected static final long sumUnscaled(Collection<Money> elements)
```
  - getPercentages
```
public static List<Percentage> getPercentages(Money... moneys)
```
    Calculates a list of Percentage objects reflecting the distribution of money within the given money list. Please note that the scale of these percentages is zero.
    
    See Also:
    
    getPercentages(int, Money...)
  - getPercentages
```
public static List<Percentage> getPercentages(int scale,
                                              Money... moneys)
```
    Calculates a list of Percentage objects reflecting the distribution of money within the given money list. The specified scale is defining the precision of these percentages.
    
    See Also:
    
    getPercentages(Money...)
  - getPercentages
```
public static List<Percentage> getPercentages(List<Money> moneys,
                                              int scale)
```
    Calculates a list of Percentage objects reflecting the distribution of money within the given money list. The specified scale is defining the precision of these percentages.
    
    See Also:
    
    getPercentages(Money...)
  - getSortedPositionTable
```
protected static int[] getSortedPositionTable(List<Money> moneyList)
```

Class Money

Nested Class Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

Money

Money

Money

Money

Method Detail

valueOf

valueOf

valueOf

zero

getCurrency

getAmount

assertCurreniesAreEqual

assertCurreniesAreEqual

add

subtract

hashCode

equals

toString

split

split

checkPercentages

sortByMoneyAscending

sortByMoney

sortByMoneyDescending

sortAscending

sortDescending

sum

sum

sum

sumUnscaled

sumUnscaled

getPercentages

getPercentages

getPercentages

getSortedPositionTable