BigMoney (OpenGamma Strata Basics)

java.lang.Object
- com.opengamma.strata.basics.currency.BigMoney

All Implemented Interfaces:

FxConvertible<BigMoney>, Serializable, Comparable<BigMoney>
```
public class BigMoney
extends Object
implements FxConvertible<BigMoney>, Comparable<BigMoney>, Serializable
```
A monetary amount, held to a maximum of 12 decimal places.
This class is similar to Money, but permits any number of decimal places. The amount will always have at least the number of decimal places of the currency. Trailing zeroes are stripped.
This class is immutable and thread-safe.

See Also:

Serialized Form

Method Summary

All Methods Static Methods Instance Methods Concrete Methods Deprecated Methods
Modifier and Type	Method and Description
`int`	`compareTo(BigMoney other)` Compares this money to another.
`BigMoney`	`convertedTo(Currency resultCurrency, BigDecimal fxRate)` Converts this amount to an equivalent amount the specified currency.
`BigMoney`	`convertedTo(Currency resultCurrency, Decimal fxRate)` Converts this amount to an equivalent amount the specified currency.
`BigMoney`	`convertedTo(Currency resultCurrency, FxRateProvider rateProvider)` Converts this amount to an equivalent amount in the specified currency.
`boolean`	`equals(Object obj)` Checks if this money equals another.
`BigDecimal`	`getAmount()` Deprecated. Use `getValue()`
`Currency`	`getCurrency()` Gets the currency.
`Decimal`	`getValue()` Gets the numeric amount of the money.
`int`	`hashCode()` Returns a suitable hash code for the currency.
`boolean`	`isGreaterThan(BigMoney otherAmount)` Checks if this amount is greater than the other amount.
`boolean`	`isGreaterThanEqualTo(BigMoney otherAmount)` Checks if this amount is greater than or equal to the other amount.
`boolean`	`isLessThan(BigMoney otherAmount)` Checks if this amount is less than the other amount.
`boolean`	`isLessThanEqualTo(BigMoney otherAmount)` Checks if this amount is less than or equal to the other amount.
`boolean`	`isNegative()` Checks if the amount is negative.
`boolean`	`isPositive()` Checks if the amount is positive.
`boolean`	`isZero()` Checks if the amount is zero.
`BigMoney`	`map(UnaryOperator<Decimal> mapper)` Applies an operation to the amount.
`BigMoney`	`mapAmount(UnaryOperator<BigDecimal> mapper)` Deprecated. Use `map(UnaryOperator)`, potentially using a lambda `decimal -> decimal.mapAsBigDecimal(mapper)`
`BigMoney`	`minus(BigMoney amountToSubtract)` Returns a copy of this `BigMoney` with the specified amount subtracted.
`BigMoney`	`multipliedBy(long valueToMultiplyBy)` Returns a copy of this `BigMoney` with the amount multiplied.
`BigMoney`	`negated()` Returns a copy of this `BigMoney` with the amount negated.
`BigMoney`	`negative()` Returns a copy of this `BigMoney` with a negative amount.
`static BigMoney`	`of(CurrencyAmount currencyAmount)` Obtains an instance of `BigMoney` for the specified `CurrencyAmount`.
`static BigMoney`	`of(Currency currency, BigDecimal amount)` Obtains an instance of `BigMoney` for the specified currency and amount.
`static BigMoney`	`of(Currency currency, Decimal amount)` Obtains an instance of `BigMoney` for the specified currency and amount.
`static BigMoney`	`of(Currency currency, double amount)` Obtains an instance of `BigMoney` for the specified currency and amount.
`static BigMoney`	`of(Money money)` Obtains an instance of `BigMoney` for the specified `Money`.
`static BigMoney`	`parse(String amountStr)` Parses the string to produce a `BigMoney`.
`BigMoney`	`plus(BigMoney amountToAdd)` Returns a copy of this `BigMoney` with the specified amount added.
`BigMoney`	`positive()` Returns a copy of this `BigMoney` with a positive amount.
`BigMoney`	`roundToScale(int desiredScale, RoundingMode roundingMode)` Returns a copy of this `BigMoney` with the amount rounded to the specified scale.
`CurrencyAmount`	`toCurrencyAmount()` Converts this monetary amount to the equivalent `CurrencyAmount`.
`Money`	`toMoney()` Converts this monetary amount to the equivalent `Money`.
`String`	`toString()` Gets the amount as a string.
`static BigMoney`	`zero(Currency currency)` Obtains a zero amount instance of `BigMoney` for the specified currency.

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

- Method Detail
  - zero
```
public static BigMoney zero(Currency currency)
```
    Obtains a zero amount instance of BigMoney for the specified currency.
    
    Parameters:
    
    currency - the currency the amount is in
    
    Returns:
    
    the zero amount instance
  - of
```
public static BigMoney of(CurrencyAmount currencyAmount)
```
    Obtains an instance of BigMoney for the specified CurrencyAmount.
    
    Parameters:
    
    currencyAmount - the instance of CurrencyAmount wrapping the currency and amount.
    
    Returns:
    
    the currency amount
  - of
```
public static BigMoney of(Money money)
```
    Obtains an instance of BigMoney for the specified Money.
    
    Parameters:
    
    money - the instance of Money wrapping the currency and amount.
    
    Returns:
    
    the currency amount
  - of
```
public static BigMoney of(Currency currency,
                          double amount)
```
    Obtains an instance of BigMoney for the specified currency and amount.
    
    Parameters:
    
    currency - the currency the amount is in
    
    amount - the amount of the currency to represent
    
    Returns:
    
    the currency amount
  - of
```
public static BigMoney of(Currency currency,
                          BigDecimal amount)
```
    Obtains an instance of BigMoney for the specified currency and amount.
    
    Parameters:
    
    currency - the currency the amount is in
    
    amount - the amount of the currency to represent, as an instance of BigDecimal
    
    Returns:
    
    the currency amount
  - of
```
public static BigMoney of(Currency currency,
                          Decimal amount)
```
    Obtains an instance of BigMoney for the specified currency and amount.
    
    Parameters:
    
    currency - the currency the amount is in
    
    amount - the amount of the currency to represent, as an instance of Decimal
    
    Returns:
    
    the currency amount
  - parse
```
public static BigMoney parse(String amountStr)
```
    Parses the string to produce a BigMoney.
    This parses the toString format of '${currency} ${amount}'.
    
    Parameters:
    
    amountStr - the amount string
    
    Returns:
    
    the currency amount
    
    Throws:
    
    IllegalArgumentException - if the amount cannot be parsed
  - getCurrency
```
public Currency getCurrency()
```
    Gets the currency.
    For example, in the value 'GBP 12.34' the currency is 'GBP'.
    
    Returns:
    
    the currency
  - getAmount
```
@Deprecated
public BigDecimal getAmount()
```
    Deprecated. Use getValue()
    
    Gets the numeric amount of the money, as a BigDecimal.
    For example, in the amount 'GBP 12.345' the decimal value returned is '12.345'.
    
    Returns:
    
    the amount, with a scale from 0 to 12
  - getValue
```
public Decimal getValue()
```
    Gets the numeric amount of the money.
    For example, in the amount 'GBP 12.345' the decimal value returned is '12.345'.
    
    Returns:
    
    the amount, with a scale from 0 to 12
  - plus
```
public BigMoney plus(BigMoney amountToAdd)
```
    Returns a copy of this BigMoney with the specified amount added.
    This adds the specified amount to this monetary amount, returning a new object.
    This instance is immutable and unaffected by this method.
    
    Parameters:
    
    amountToAdd - the amount to add, in the same currency
    
    Returns:
    
    an amount based on this with the specified amount added
    
    Throws:
    
    IllegalArgumentException - if the currencies are not equal
  - minus
```
public BigMoney minus(BigMoney amountToSubtract)
```
    Returns a copy of this BigMoney with the specified amount subtracted.
    This subtracts the specified amount to this monetary amount, returning a new object.
    This instance is immutable and unaffected by this method.
    
    Parameters:
    
    amountToSubtract - the amount to subtract, in the same currency
    
    Returns:
    
    an amount based on this with the specified amount subtracted
    
    Throws:
    
    IllegalArgumentException - if the currencies are not equal
  - multipliedBy
```
public BigMoney multipliedBy(long valueToMultiplyBy)
```
    Returns a copy of this BigMoney with the amount multiplied.
    This takes this amount and multiplies it by the specified value.
    This instance is immutable and unaffected by this method.
    
    Parameters:
    
    valueToMultiplyBy - the scalar amount to multiply by
    
    Returns:
    
    an amount based on this with the amount multiplied
  - map
```
public BigMoney map(UnaryOperator<Decimal> mapper)
```
    Applies an operation to the amount.
    This is generally used to apply a mathematical operation to the amount. For example, the operator could multiply the amount by a constant, or take the inverse.
```
   abs = base.mapAmount(value -> value.abs());
 
```
    Parameters:
    
    mapper - the operator to be applied to the amount
    
    Returns:
    
    a copy of this amount with the mapping applied to the original amount
  - mapAmount
```
@Deprecated
public BigMoney mapAmount(UnaryOperator<BigDecimal> mapper)
```
    Deprecated. Use map(UnaryOperator), potentially using a lambda decimal -> decimal.mapAsBigDecimal(mapper)
    Applies an operation to the amount.
    This is generally used to apply a mathematical operation to the amount. For example, the operator could multiply the amount by a constant, or take the inverse.
```
   abs = base.mapAmount(value -> value.abs());
 
```
    Parameters:
    
    mapper - the operator to be applied to the amount
    
    Returns:
    
    a copy of this amount with the mapping applied to the original amount
  - isGreaterThan
```
public boolean isGreaterThan(BigMoney otherAmount)
```
    Checks if this amount is greater than the other amount.
    
    Parameters:
    
    otherAmount - the other amount
    
    Returns:
    
    true if this amount is greater than the other amount
    
    Throws:
    
    IllegalArgumentException - if the currencies are not equal
  - isGreaterThanEqualTo
```
public boolean isGreaterThanEqualTo(BigMoney otherAmount)
```
    Checks if this amount is greater than or equal to the other amount.
    
    Parameters:
    
    otherAmount - the other amount
    
    Returns:
    
    true if this amount is greater than or equal to the other amount
    
    Throws:
    
    IllegalArgumentException - if the currencies are not equal
  - isLessThan
```
public boolean isLessThan(BigMoney otherAmount)
```
    Checks if this amount is less than the other amount.
    
    Parameters:
    
    otherAmount - the other amount
    
    Returns:
    
    true if this amount is less than the other amount
    
    Throws:
    
    IllegalArgumentException - if the currencies are not equal
  - isLessThanEqualTo
```
public boolean isLessThanEqualTo(BigMoney otherAmount)
```
    Checks if this amount is less than or equal to the other amount.
    
    Parameters:
    
    otherAmount - the other amount
    
    Returns:
    
    true if this amount is less than or equal to the other amount
    
    Throws:
    
    IllegalArgumentException - if the currencies are not equal
  - roundToScale
```
public BigMoney roundToScale(int desiredScale,
                             RoundingMode roundingMode)
```
    Returns a copy of this BigMoney with the amount rounded to the specified scale.
    The underlying amount will be rounded using Decimal.roundToScale(int, RoundingMode)
    This instance is immutable and unaffected by this method.
    
    Parameters:
    
    desiredScale - the scale, positive for decimal places, negative to round the integer-part
    
    roundingMode - the rounding mode
    
    Returns:
    
    the rounded amount
    
    Throws:
    
    IllegalArgumentException - if the scale is -18 or less
  - isZero
```
public boolean isZero()
```
    Checks if the amount is zero.
    
    Returns:
    
    true if zero
  - isPositive
```
public boolean isPositive()
```
    Checks if the amount is positive.
    Zero and negative amounts return false.
    
    Returns:
    
    true if positive
  - isNegative
```
public boolean isNegative()
```
    Checks if the amount is negative.
    Zero and positive amounts return false.
    
    Returns:
    
    true if negative
  - negated
```
public BigMoney negated()
```
    Returns a copy of this BigMoney with the amount negated.
    This takes this amount and negates it.
    This instance is immutable and unaffected by this method.
    
    Returns:
    
    an amount based on this with the amount negated
  - positive
```
public BigMoney positive()
```
    Returns a copy of this BigMoney with a positive amount.
    The result of this method will always be positive, where the amount is equal to abs(amount).
    This instance is immutable and unaffected by this method.
    
    Returns:
    
    an amount based on this where the amount is positive
  - negative
```
public BigMoney negative()
```
    Returns a copy of this BigMoney with a negative amount.
    The result of this method will always be negative, equal to -.abs(amount).
    This instance is immutable and unaffected by this method.
    
    Returns:
    
    an amount based on this where the amount is negative
  - toCurrencyAmount
```
public CurrencyAmount toCurrencyAmount()
```
    Converts this monetary amount to the equivalent CurrencyAmount.
    
    Returns:
    
    the equivalent CurrencyAmount
  - toMoney
```
public Money toMoney()
```
    Converts this monetary amount to the equivalent Money.
    
    Returns:
    
    the equivalent Money
  - convertedTo
```
public BigMoney convertedTo(Currency resultCurrency,
                            BigDecimal fxRate)
```
    Converts this amount to an equivalent amount the specified currency.
    The result will be expressed in terms of the given currency, converting using the specified FX rate.
    For example, if this represents 'GBP 100' and this method is called with arguments (USD, 1.6) then the result will be 'USD 160'.
    
    Parameters:
    
    resultCurrency - the currency of the result
    
    fxRate - the FX rate from this currency to the result currency
    
    Returns:
    
    the converted instance, which should be expressed in the specified currency
    
    Throws:
    
    IllegalArgumentException - if the FX is not 1 when no conversion is required
  - convertedTo
```
public BigMoney convertedTo(Currency resultCurrency,
                            Decimal fxRate)
```
    Converts this amount to an equivalent amount the specified currency.
    The result will be expressed in terms of the given currency, converting using the specified FX rate.
    For example, if this represents 'GBP 100' and this method is called with arguments (USD, 1.6) then the result will be 'USD 160'.
    
    Parameters:
    
    resultCurrency - the currency of the result
    
    fxRate - the FX rate from this currency to the result currency
    
    Returns:
    
    the converted instance, which should be expressed in the specified currency
    
    Throws:
    
    IllegalArgumentException - if the FX is not 1 when no conversion is required
  - convertedTo
```
public BigMoney convertedTo(Currency resultCurrency,
                            FxRateProvider rateProvider)
```
    Converts this amount to an equivalent amount in the specified currency.
    The result will be expressed in terms of the given currency. If conversion is needed, the provider will be used to supply the FX rate.
    
    Specified by:
    
    convertedTo in interface FxConvertible<BigMoney>
    
    Parameters:
    
    resultCurrency - the currency of the result
    
    rateProvider - the provider of FX rates
    
    Returns:
    
    the converted instance, in the specified currency
    
    Throws:
    
    RuntimeException - if no FX rate could be found
  - compareTo
```
public int compareTo(BigMoney other)
```
    Compares this money to another.
    This compares currencies alphabetically, then by amount.
    
    Specified by:
    
    compareTo in interface Comparable<BigMoney>
    
    Parameters:
    
    other - the other amount
    
    Returns:
    
    negative if less, zero if equal, positive if greater
  - equals
```
public boolean equals(Object obj)
```
    Checks if this money equals another.
    
    Overrides:
    
    equals in class Object
    
    Parameters:
    
    obj - the other amount, null returns false
    
    Returns:
    
    true if equal
  - hashCode
```
public int hashCode()
```
    Returns a suitable hash code for the currency.
    
    Overrides:
    
    hashCode in class Object
    
    Returns:
    
    the hash code
  - toString
```
public String toString()
```
    Gets the amount as a string.
    The format is the currency code, followed by a space, followed by the amount: '${currency} ${amount}'.
    
    Overrides:
    
    toString in class Object
    
    Returns:
    
    the currency amount

Copyright 2009-Present by OpenGamma Inc. and individual contributors
Apache v2 licensed
Additional documentation can be found at strata.opengamma.io.

Class BigMoney

Method Summary

Methods inherited from class java.lang.Object

Method Detail

zero

of

of

of

of

of

parse

getCurrency

getAmount

getValue

plus

minus

multipliedBy

map

mapAmount

isGreaterThan

isGreaterThanEqualTo

isLessThan

isLessThanEqualTo

roundToScale

isZero

isPositive

isNegative

negated

positive

negative

toCurrencyAmount

toMoney

convertedTo

convertedTo

convertedTo

compareTo

equals

hashCode

toString