Fiat (bitcoinj-core 0.16-SNAPSHOT API)

java.lang.Object
- org.bitcoinj.utils.Fiat

All Implemented Interfaces:

java.io.Serializable, java.lang.Comparable<Fiat>, Monetary
```
public final class Fiat
extends java.lang.Object
implements Monetary, java.lang.Comparable<Fiat>, java.io.Serializable
```
Represents a monetary fiat value. It was decided to not fold this into Coin because of type safety. Fiat values always come with an attached currency code. This class is immutable.

See Also:

Serialized Form

Field Summary

Fields
Modifier and Type	Field and Description
`java.lang.String`	`currencyCode`
`static int`	`SMALLEST_UNIT_EXPONENT` The absolute value of exponent of the value of a "smallest unit" in scientific notation.
`long`	`value` The number of smallest units of this monetary value.

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`Fiat`	`add(Fiat value)`
`int`	`compareTo(Fiat other)`
`long`	`divide(Fiat divisor)`
`Fiat`	`divide(long divisor)`
`Fiat[]`	`divideAndRemainder(long divisor)`
`boolean`	`equals(java.lang.Object o)`
`java.lang.String`	`getCurrencyCode()`
`long`	`getValue()` Returns the number of "smallest units" of this monetary value.
`int`	`hashCode()`
`boolean`	`isGreaterThan(Fiat other)` Returns true if the monetary value represented by this instance is greater than that of the given other Fiat, otherwise false.
`boolean`	`isLessThan(Fiat other)` Returns true if the monetary value represented by this instance is less than that of the given other Fiat, otherwise false.
`boolean`	`isNegative()` Returns true if and only if this instance represents a monetary value less than zero, otherwise false.
`boolean`	`isPositive()` Returns true if and only if this instance represents a monetary value greater than zero, otherwise false.
`boolean`	`isZero()` Returns true if and only if this instance represents zero monetary value, otherwise false.
`long`	`longValue()` Returns the number of "smallest units" of this monetary value.
`Fiat`	`multiply(long factor)`
`Fiat`	`negate()`
`static Fiat`	`parseFiat(java.lang.String currencyCode, java.lang.String str)` Parses an amount expressed in the way humans are used to.
`static Fiat`	`parseFiatInexact(java.lang.String currencyCode, java.lang.String str)` Parses an amount expressed in the way humans are used to.
`int`	`signum()`
`int`	`smallestUnitExponent()` Returns the absolute value of exponent of the value of a "smallest unit" in scientific notation.
`Fiat`	`subtract(Fiat value)`
`java.lang.String`	`toFriendlyString()` Returns the value as a 0.12 type string.
`java.lang.String`	`toPlainString()` Returns the value as a plain string.
`java.lang.String`	`toString()`
`static Fiat`	`valueOf(java.lang.String currencyCode, long value)`

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

- Field Detail
  - SMALLEST_UNIT_EXPONENT
```
public static final int SMALLEST_UNIT_EXPONENT
```
    The absolute value of exponent of the value of a "smallest unit" in scientific notation. We picked 4 rather than 2, because in financial applications it's common to use sub-cent precision.
    
    See Also:
    
    Constant Field Values
  - value
```
public final long value
```
    The number of smallest units of this monetary value.
  - currencyCode
```
public final java.lang.String currencyCode
```
- Method Detail
  - valueOf
```
public static Fiat valueOf(java.lang.String currencyCode,
                           long value)
```
  - smallestUnitExponent
```
public int smallestUnitExponent()
```
    Description copied from interface: Monetary
    
    Returns the absolute value of exponent of the value of a "smallest unit" in scientific notation. For Bitcoin, a satoshi is worth 1E-8 so this would be 8.
    
    Specified by:
    
    smallestUnitExponent in interface Monetary
  - getValue
```
public long getValue()
```
    Returns the number of "smallest units" of this monetary value.
    
    Specified by:
    
    getValue in interface Monetary
  - getCurrencyCode
```
public java.lang.String getCurrencyCode()
```
  - parseFiat
```
public static Fiat parseFiat(java.lang.String currencyCode,
                             java.lang.String str)
```
    Parses an amount expressed in the way humans are used to.
    
    This takes string in a format understood by BigDecimal.BigDecimal(String), for example "0", "1", "0.10", "1.23E3", "1234.5E-5".
    
    Throws:
    
    java.lang.IllegalArgumentException - if you try to specify more than 4 digits after the comma, or a value out of range.
  - parseFiatInexact
```
public static Fiat parseFiatInexact(java.lang.String currencyCode,
                                    java.lang.String str)
```
    Parses an amount expressed in the way humans are used to. The amount is cut to 4 digits after the comma.
    
    This takes string in a format understood by BigDecimal.BigDecimal(String), for example "0", "1", "0.10", "1.23E3", "1234.5E-5".
    
    Throws:
    
    java.lang.IllegalArgumentException - if you try to specify a value out of range.
  - add
```
public Fiat add(Fiat value)
```
  - subtract
```
public Fiat subtract(Fiat value)
```
  - multiply
```
public Fiat multiply(long factor)
```
  - divide
```
public Fiat divide(long divisor)
```
  - divideAndRemainder
```
public Fiat[] divideAndRemainder(long divisor)
```
  - divide
```
public long divide(Fiat divisor)
```
  - isPositive
```
public boolean isPositive()
```
    Returns true if and only if this instance represents a monetary value greater than zero, otherwise false.
  - isNegative
```
public boolean isNegative()
```
    Returns true if and only if this instance represents a monetary value less than zero, otherwise false.
  - isZero
```
public boolean isZero()
```
    Returns true if and only if this instance represents zero monetary value, otherwise false.
  - isGreaterThan
```
public boolean isGreaterThan(Fiat other)
```
    Returns true if the monetary value represented by this instance is greater than that of the given other Fiat, otherwise false.
  - isLessThan
```
public boolean isLessThan(Fiat other)
```
    Returns true if the monetary value represented by this instance is less than that of the given other Fiat, otherwise false.
  - signum
```
public int signum()
```
    Specified by:
    
    signum in interface Monetary
  - negate
```
public Fiat negate()
```
  - longValue
```
public long longValue()
```
    Returns the number of "smallest units" of this monetary value. It's deprecated in favour of accessing value directly.
  - toFriendlyString
```
public java.lang.String toFriendlyString()
```
    Returns the value as a 0.12 type string. More digits after the decimal place will be used if necessary, but two will always be present.
  - toPlainString
```
public java.lang.String toPlainString()
```
    Returns the value as a plain string. The result is unformatted with no trailing zeroes. For instance, a value of 150000 "smallest units" gives an output string of "0.0015".
  - toString
```
public java.lang.String toString()
```
    Overrides:
    
    toString in class java.lang.Object
  - equals
```
public boolean equals(java.lang.Object o)
```
    Overrides:
    
    equals in class java.lang.Object
  - hashCode
```
public int hashCode()
```
    Overrides:
    
    hashCode in class java.lang.Object
  - compareTo
```
public int compareTo(Fiat other)
```
    Specified by:
    
    compareTo in interface java.lang.Comparable<Fiat>

Class Fiat

Field Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

SMALLEST_UNIT_EXPONENT

value

currencyCode

Method Detail

valueOf

smallestUnitExponent

getValue

getCurrencyCode

parseFiat

parseFiatInexact

add

subtract

multiply

divide

divideAndRemainder

divide

isPositive

isNegative

isZero

isGreaterThan

isLessThan

signum

negate

longValue

toFriendlyString

toPlainString

toString

equals

hashCode

compareTo