java.lang.Object

alexiil.mc.lib.attributes.fluid.amount.FluidAmount

All Implemented Interfaces:: java.lang.Comparable<FluidAmount>

public final class FluidAmount
extends java.lang.Object

A simple mixed fraction. The value represented by this can be calculated with this: "whole + (numerator / denominator)". Negative values are indicated with both whole and numerator being negative - it is never permissible for only one of them to be less than 0 and the other to be greater than 0.

Note: This class is intended to become a value-based class, so it will (eventually) obey the rules set out in https://openjdk.java.net/jeps/390.

Nested Class Summary

Nested Classes
Modifier and Type	Class	Description
`static class`	`FluidAmount.FluidMergeResult`
`static class`	`FluidAmount.FluidMergeRounding`	Specifies how merged `FluidAmount`'s should handle rounding.
`static class`	`FluidAmount.SafeAddResult`

Field Summary

Fields
Modifier and Type	Field	Description
`static FluidAmount`	`A_MILLION`	A very large amount of fluid - one million buckets.
`static FluidAmount`	`ABSOLUTE_MAXIMUM`	The maximum possible value that a valid `FluidAmount` can hold.
`static FluidAmount`	`ABSOLUTE_MINIMUM`	The minimum possible value that a valid `FluidAmount` can hold.
`static FluidAmount`	`BOTTLE`	One bottle is equal to a third of a bucket.
`static FluidAmount`	`BUCKET`	One bucket of fluid - which is always `ONE`.
`long`	`denominator`	Always greater than 0.
`static FluidAmount`	`MAX_BUCKETS`	`Long.MAX_VALUE` of buckets.
`static FluidAmount`	`MAX_VALUE`	Deprecated. As `MAX_BUCKETS` should generally be used instead, however if you really need the absolute value then you can use `ABSOLUTE_MAXIMUM`.
`static FluidAmount`	`MIN_BUCKETS`	`Long.MIN_VALUE` of buckets.
`static FluidAmount`	`MIN_VALUE`	Deprecated. As `MIN_BUCKETS` should generally be used instead, however if you really need the absolute minimum value then you can use `ABSOLUTE_MINIMUM`.
`static FluidAmount`	`NEGATIVE_ONE`
`long`	`numerator`
`static FluidAmount`	`ONE`
`long`	`whole`
`static FluidAmount`	`ZERO`

Constructor Summary

Constructors

Constructor Description

FluidAmount(long whole)
Deprecated.
As ofWhole(long) should be used instead.

Method Summary

Modifier and Type	Method	Description
`FluidAmount`	`add(long by)`	Adds the given long value to this `FluidAmount`, without performing any checking or saturation.
`BigFluidAmount`	`add(BigFluidAmount by)`	Directly adds the given `BigFluidAmount` to this one.
`FluidAmount`	`add(FluidAmount other)`	The recommended method for adding two `FluidAmount`'s together if you don't want to think about inexact answers.
`int`	`as1620()`
`int`	`as1620(java.math.RoundingMode rounding)`
`BigFluidAmount`	`asBigInt()`
`double`	`asInexactDouble()`
`int`	`asInt(int base)`
`int`	`asInt(int base, java.math.RoundingMode rounding)`
`long`	`asLong(long base)`
`long`	`asLong(long base, java.math.RoundingMode rounding)`
`FluidAmount`	`asLongIntExact()`
`BigFluidAmount`	`bigAdd(FluidAmount by)`	Directly adds the given `FluidAmount` to this one, returning the result as a `BigFluidAmount`.
`BigFluidAmount`	`bigDiv(FluidAmount by)`
`BigFluidAmount`	`bigMul(FluidAmount by)`
`BigFluidAmount`	`bigReciprocal()`
`FluidAmount`	`checkedAdd(FluidAmount by)`	Directly adds the given `FluidAmount` to this one.
`FluidAmount`	`checkedDiv(long by)`
`FluidAmount`	`checkedDiv(FluidAmount by)`
`FluidAmount`	`checkedMul(long by)`
`FluidAmount`	`checkedMul(FluidAmount by)`
`FluidAmount`	`checkedSub(FluidAmount by)`
`int`	`compareTo(FluidAmount o)`	Null is treated as zero
`FluidAmount`	`div(long other)`	The recommended method for dividing this by a `Long` if you don't want to think about inexact answers.
`BigFluidAmount`	`div(BigFluidAmount by)`
`FluidAmount`	`div(FluidAmount other)`	The recommended method for dividing this by another `FluidAmount` if you don't want to think about inexact answers.
`boolean`	`equals(FluidAmount other)`
`boolean`	`equals(java.lang.Object obj)`
`static FluidAmount`	`fromDouble(double value)`	Deprecated. Use `parse(String)` instead.
`static FluidAmount`	`fromMcBuffer(net.minecraft.network.PacketByteBuf buffer)`	Reads a `FluidAmount` from a minecraft `PacketByteBuf`, using 3 `variable-length longs`.
`static FluidAmount`	`fromNbt(net.minecraft.nbt.CompoundTag tag)`
`static FluidAmount`	`fromStdBuffer(io.netty.buffer.ByteBuf buffer)`	Reads a `FluidAmount` from a standard netty `ByteBuf`, using 3 `longs`.
`BigFluidAmount`	`gcd(BigFluidAmount other)`
`BigFluidAmount`	`gcd(FluidAmount other)`
`long`	`getCountOf(FluidAmount by)`
`FluidAmount`	`getDivisor()`
`int`	`hashCode()`
`boolean`	`isGreaterThan(FluidAmount other)`	Null is treated as zero
`boolean`	`isGreaterThanOrEqual(FluidAmount other)`	Null is treated as zero
`boolean`	`isLessThan(FluidAmount other)`	Null is treated as zero
`boolean`	`isLessThanOrEqual(FluidAmount other)`	Null is treated as zero
`boolean`	`isNegative()`
`boolean`	`isOverflow()`
`boolean`	`isPositive()`
`boolean`	`isZero()`
`FluidAmount`	`lcm(FluidAmount other)`
`FluidAmount`	`max(FluidAmount other)`
`static FluidAmount.FluidMergeResult`	`merge(FluidAmount target, FluidAmount toAdd)`	Calls `merge(FluidAmount, FluidAmount, FluidMergeRounding)` with a `FluidAmount.FluidMergeRounding` of `ROUND_HALF_EVEN`.
`static FluidAmount.FluidMergeResult`	`merge(FluidAmount target, FluidAmount toAdd, long denominatorTarget, long denominatorAdd)`
`static FluidAmount.FluidMergeResult`	`merge(FluidAmount target, FluidAmount toAdd, FluidAmount.FluidMergeRounding rounding)`
`FluidAmount`	`min(FluidAmount other)`
`FluidAmount`	`mul(long by)`	The recommended method for multiplying this by a long if you don't want to think about inexact answers.
`BigFluidAmount`	`mul(BigFluidAmount by)`
`FluidAmount`	`mul(FluidAmount by)`	The recommended method for multiplying two `FluidAmount`'s together if you don't want to think about inexact answers.
`FluidAmount`	`negate()`
`static FluidAmount`	`of(long numerator, long denominator)`	Creates a new `FluidAmount` with the given values.
`static FluidAmount`	`of(long whole, long numerator, long denominator)`	Creates a new `FluidAmount` with the given values.
`static FluidAmount`	`of1620(int amount)`	Legacy conversion method for creating a fraction with the given amount as it's numerator, and 1620 as it's denominator
`static FluidAmount`	`ofWhole(long whole)`	Creates a new `FluidAmount` with the given values.
`static FluidAmount`	`parse(java.lang.String text)`	Attempts to parse the given text as a `FluidAmount`.
`FluidAmount`	`reciprocal()`
`FluidAmount`	`roundedAdd(FluidAmount other)`
`FluidAmount`	`roundedAdd(FluidAmount other, java.math.RoundingMode rounding)`
`FluidAmount`	`roundedDiv(long by)`
`FluidAmount`	`roundedDiv(long by, java.math.RoundingMode rounding)`
`FluidAmount`	`roundedDiv(FluidAmount by)`
`FluidAmount`	`roundedDiv(FluidAmount by, java.math.RoundingMode rounding)`
`FluidAmount`	`roundedMul(long by)`
`FluidAmount`	`roundedMul(long by, java.math.RoundingMode rounding)`
`FluidAmount`	`roundedMul(FluidAmount by)`
`FluidAmount`	`roundedMul(FluidAmount by, java.math.RoundingMode rounding)`
`FluidAmount`	`roundedSub(FluidAmount by)`
`FluidAmount`	`roundedSub(FluidAmount by, java.math.RoundingMode rounding)`
`FluidAmount.SafeAddResult`	`safeAdd(FluidAmount other)`	Safely adds the given `FluidAmount` to this one, returning the merged result.
`FluidAmount.SafeAddResult`	`safeAdd(FluidAmount other, java.math.RoundingMode rounding)`	Safely adds the given `FluidAmount` to this one, returning the merged result.
`FluidAmount.SafeAddResult`	`safeSub(FluidAmount by)`
`FluidAmount.SafeAddResult`	`safeSub(FluidAmount by, java.math.RoundingMode rounding)`
`FluidAmount`	`saturatedAdd(FluidAmount by)`	Similar to `checkedAdd(FluidAmount)`, but returns either `MAX_BUCKETS` or `MIN_BUCKETS` instead of throwing an exception.
`FluidAmount`	`saturatedDiv(long by)`
`FluidAmount`	`saturatedDiv(FluidAmount by)`
`FluidAmount`	`saturatedMul(long by)`
`FluidAmount`	`saturatedMul(FluidAmount by)`
`FluidAmount`	`saturatedSub(FluidAmount by)`
`int`	`sign()`
`FluidAmount`	`sub(long by)`
`BigFluidAmount`	`sub(BigFluidAmount by)`
`FluidAmount`	`sub(FluidAmount other)`	The recommended method for subtracting another `FluidAmount` from this if you don't want to think about inexact answers.
`java.lang.String`	`toDisplayString()`
`void`	`toMcBuffer(net.minecraft.network.PacketByteBuf buffer)`	Writes a `FluidAmount` to a minecraft `PacketByteBuf`, using 3 `variable-length longs`.
`net.minecraft.nbt.CompoundTag`	`toNbt()`
`java.lang.String`	`toParseableString()`
`void`	`toStdBuffer(io.netty.buffer.ByteBuf buffer)`	Writes a `FluidAmount` to a standard netty `ByteBuf`, using 3 `longs`.
`java.lang.String`	`toString()`
`static java.lang.Object`	`tryParse(java.lang.String text)`	Attempts to parse the given text as a `FluidAmount`.

Methods inherited from class java.lang.Object

clone, finalize, getClass, notify, notifyAll, wait, wait, wait

Field Details
- ZERO
  
  public static final FluidAmount ZERO
- ONE
  
  public static final FluidAmount ONE
- NEGATIVE_ONE
  
  public static final FluidAmount NEGATIVE_ONE
- A_MILLION
  
  public static final FluidAmount A_MILLION
  
  A very large amount of fluid - one million buckets. Used primarily in cases where we need to test if any fluid is insertable, so we go above normal values (without going so far out of range to make common calculations overflow into BigFluidAmount).
- BUCKET
  
  public static final FluidAmount BUCKET
  
  One bucket of fluid - which is always ONE.
- BOTTLE
  
  public static final FluidAmount BOTTLE
  
  One bottle is equal to a third of a bucket.
- MAX_BUCKETS
  
  public static final FluidAmount MAX_BUCKETS
  
  Long.MAX_VALUE of buckets.
- MIN_BUCKETS
  
  public static final FluidAmount MIN_BUCKETS
  
  Long.MIN_VALUE of buckets.
- ABSOLUTE_MAXIMUM
  
  public static final FluidAmount ABSOLUTE_MAXIMUM
  
  The maximum possible value that a valid FluidAmount can hold. It's not recommended to use this as it can cause headaches when adding or subtracting values from this.
- ABSOLUTE_MINIMUM
  
  public static final FluidAmount ABSOLUTE_MINIMUM
  
  The minimum possible value that a valid FluidAmount can hold. It's not recommended to use this as it can cause headaches when adding or subtracting values from this.
- MAX_VALUE
  
  @Deprecated public static final FluidAmount MAX_VALUE
  
  Deprecated.
  As MAX_BUCKETS should generally be used instead, however if you really need the absolute value then you can use ABSOLUTE_MAXIMUM.
  
  The maximum possible value that a valid FluidAmount can hold. It's not recommended to use this as it can cause headaches when adding or subtracting values from this.
- MIN_VALUE
  
  @Deprecated public static final FluidAmount MIN_VALUE
  
  Deprecated.
  As MIN_BUCKETS should generally be used instead, however if you really need the absolute minimum value then you can use ABSOLUTE_MINIMUM.
  
  The minimum possible value that a valid FluidAmount can hold. It's not recommended to use this as it can cause headaches when adding or subtracting values from this.
- whole
  
  public final long whole
- numerator
  
  public final long numerator
- denominator
  
  public final long denominator
  
  Always greater than 0.
Constructor Details
- FluidAmount
  
  @Deprecated public FluidAmount(long whole)
  
  Deprecated.
  As ofWhole(long) should be used instead.
  
  Constructs a new FluidAmount with the given whole value. The numerator is set to 0, and the denominator is set to 1.
Method Details
- ofWhole
  
  public static FluidAmount ofWhole(long whole)
  
  Creates a new FluidAmount with the given values. This will reduce the fraction into it's simplest form.
- of
  
  public static FluidAmount of(long numerator, long denominator)
  
  Creates a new FluidAmount with the given values. This will reduce the fraction into it's simplest form.
- of1620
  
  public static FluidAmount of1620(int amount)
  
  Legacy conversion method for creating a fraction with the given amount as it's numerator, and 1620 as it's denominator
- of
  
  public static FluidAmount of(long whole, long numerator, long denominator)
  
  Creates a new FluidAmount with the given values. This will reduce the fraction into it's simplest form.
  
  Throws:
  
  java.lang.IllegalArgumentException - if either whole or numerator are negative, or if denominator is less than or equal to 0.
- fromDouble
  
  @Deprecated public static FluidAmount fromDouble(double value)
  
  Deprecated.
  Use parse(String) instead.
- parse
  
  public static FluidAmount parse(java.lang.String text) throws java.lang.NumberFormatException
  Attempts to parse the given text as a FluidAmount.
  The text is parsed according to the following rules:
  
  If the text is a valid Long then that is parsed and returned as if from ofWhole(long).
  
  Otherwise it must contain the following:
  
  (Optional) "-": The minus sign, which indicates that the whole part is negative.
  (Optional) "(": An opening bracket.
  A valid Long, that only contains [0-9] (From Long.parseLong(String)). This is taken as the whole
  
  Either a single "+" or "-", which indicates that the
  (Optional) "(": An opening bracket.
  A valid Long, that only contains [0-9] (From Long.parseLong(String)). This is taken as the numerator. This may be greater than the denominator.
  
  A "/" symbol.
  
  A valid Long, that only contains [0-9], and doesn't equal 0. (From Long.parseLong(String)). This is taken as the denominator
  
  Either one or two ")" symbols, matching the two optional opening "(" symbols.
  
  There can be any number of spaces between each item in the above list.
  Alternatively the first 4 items can be left off.
  For example these strings are all valid:
  
  "1"
  
  "-1"
  
  "-1 - 3 / 4"
  
  "-(1 + 3 / 4)"
  
  "1 + 3 / 4"
  
  "12 / 4"
  
  "6 + 12 / 4"
  
  "6+12/4"
  
  "-(6+12/4)"
  
  "-(6+(12/4))"
  
  "-6-(12/4)"
  Throws:
  
  java.lang.NumberFormatException - if the input text was not a valid fraction.
- tryParse
  
  public static java.lang.Object tryParse(java.lang.String text)
  
  Attempts to parse the given text as a FluidAmount. This uses the same parsing rules as parse(String), except that this returns either a FluidAmount (if it parsed correctly) or a String (if it didn't parse correctly). This will never throw an exception.
  
  Returns:
  
  String (if there's an error and _throw is false) or the parsed FluidAmount if the text could be parsed.
- fromNbt
  
  public static FluidAmount fromNbt(net.minecraft.nbt.CompoundTag tag)
- toNbt
  
  public net.minecraft.nbt.CompoundTag toNbt()
- fromStdBuffer
  
  public static FluidAmount fromStdBuffer(io.netty.buffer.ByteBuf buffer)
  
  Reads a FluidAmount from a standard netty ByteBuf, using 3 longs.
- toStdBuffer
  
  public void toStdBuffer(io.netty.buffer.ByteBuf buffer)
  
  Writes a FluidAmount to a standard netty ByteBuf, using 3 longs.
- fromMcBuffer
  
  public static FluidAmount fromMcBuffer(net.minecraft.network.PacketByteBuf buffer)
  
  Reads a FluidAmount from a minecraft PacketByteBuf, using 3 variable-length longs.
- toMcBuffer
  
  public void toMcBuffer(net.minecraft.network.PacketByteBuf buffer)
  
  Writes a FluidAmount to a minecraft PacketByteBuf, using 3 variable-length longs.
- isZero
  
  public boolean isZero()
- isNegative
  
  public boolean isNegative()
- isPositive
  
  public boolean isPositive()
- sign
  
  public int sign()
  
  Returns:
  
  The sign: Either -1 if this is negative, +1 if this is positive, or 0 if this is zero.
- isOverflow
  
  public boolean isOverflow()
  
  Returns:
  
  True if this FluidAmount has potentially overflowed out of a long. This will return true if either whole or numerator is Long.MIN_VALUE or Long.MAX_VALUE, or if denominator is Long.MAX_VALUE.
- getDivisor
  
  public FluidAmount getDivisor()
  
  Returns:
  
  The denominator represented in a new fraction, as 1/this.denominator.
- as1620
  
  public int as1620()
  
  Returns:
  
  Rounded-up value of this FluidAmount using a base of 1620.
- as1620
  
  public int as1620(java.math.RoundingMode rounding)
  
  Returns:
  
  Rounded-up value of this FluidAmount using a base of 1620.
- asInt
  
  public int asInt(int base)
  
  Returns:
  
  Rounded-up integer value of this FluidAmount using the given base. Returns Integer.MAX_VALUE or Integer.MIN_VALUE if the true value is out-of-range.
- asInt
  
  public int asInt(int base, java.math.RoundingMode rounding)
- asLong
  
  public long asLong(long base)
  
  Returns:
  
  Rounded-up long value of this FluidAmount using the given base. Returns Long.MAX_VALUE or Long.MIN_VALUE if the true value is out-of-range.
- asLong
  
  public long asLong(long base, java.math.RoundingMode rounding)
  
  Returns:
  
  Rounded-up long value of this FluidAmount using the given base. Returns Long.MAX_VALUE or Long.MIN_VALUE if the true value is out-of-range.
- equals
  
  public boolean equals(java.lang.Object obj)
  
  Overrides:
  
  equals in class java.lang.Object
- hashCode
  
  public int hashCode()
  
  Overrides:
  
  hashCode in class java.lang.Object
- toDisplayString
  
  public java.lang.String toDisplayString()
  
  Returns:
  
  A string version of this FluidAmount that should be shown to players.
- toString
  
  public java.lang.String toString()
  
  Overrides:
  
  toString in class java.lang.Object
- toParseableString
  
  public java.lang.String toParseableString()
  
  Returns:
  
  This FluidAmount represented as a string that could be parsed by parse(String) to return another FluidAmount equal to itself.
- equals
  
  public boolean equals(FluidAmount other)
  
  Returns:
  
  True if the number that this FluidAmount represents is equal to the number that the given FluidAmount represents.
- compareTo
  
  public int compareTo(@Nullable FluidAmount o)
  
  Null is treated as zero
  
  Specified by:
  
  compareTo in interface java.lang.Comparable<FluidAmount>
- asInexactDouble
  
  public double asInexactDouble()
- negate
  
  public FluidAmount negate()
- lcm
  
  public FluidAmount lcm(FluidAmount other)
- add
  
  public FluidAmount add(@Nullable FluidAmount other)
  
  The recommended method for adding two FluidAmount's together if you don't want to think about inexact answers.
  (Internally this calls safeAdd(FluidAmount) if you want to know the details).
  
  Parameters:
  
  other - The other FluidAmount. Null values will return "this".
- safeAdd
  
  public FluidAmount.SafeAddResult safeAdd(@Nullable FluidAmount other, java.math.RoundingMode rounding)
  
  Safely adds the given FluidAmount to this one, returning the merged result. Unlike checkedAdd(FluidAmount) this will only throw an ArithmeticException if the result is out-of-range and the rounding mode is RoundingMode.UNNECESSARY, instead it will round the real answer to the nearest valid FluidAmount (using BigFluidAmount.asLongIntRounded(RoundingMode))
- safeAdd
  
  public FluidAmount.SafeAddResult safeAdd(@Nullable FluidAmount other)
  
  Safely adds the given FluidAmount to this one, returning the merged result. Unlike checkedAdd(FluidAmount) this will never throw an ArithmeticException if the result is out-of-range, instead it will round the real answer to the nearest valid FluidAmount (using BigFluidAmount.asLongIntRounded(RoundingMode) with a rounding mode of HALF_EVEN).
- roundedAdd
  
  public FluidAmount roundedAdd(@Nullable FluidAmount other, java.math.RoundingMode rounding)
  
  Returns:
  
  the result of safeAdd(FluidAmount, RoundingMode).roundedResult.
- roundedAdd
  
  public FluidAmount roundedAdd(@Nullable FluidAmount other)
  
  Returns:
  
  the result of safeAdd(FluidAmount).roundedResult.
- add
  
  public FluidAmount add(long by)
  
  Adds the given long value to this FluidAmount, without performing any checking or saturation.
- checkedAdd
  
  public FluidAmount checkedAdd(@Nullable FluidAmount by)
  
  Directly adds the given FluidAmount to this one.
  
  Parameters:
  
  by - The amount to add. If it's null or zero then "this" will be returned.
  
  Throws:
  
  java.lang.ArithmeticException - if the result doesn't fit into a FluidAmount.
- saturatedAdd
  
  public FluidAmount saturatedAdd(@Nullable FluidAmount by)
  
  Similar to checkedAdd(FluidAmount), but returns either MAX_BUCKETS or MIN_BUCKETS instead of throwing an exception.
- bigAdd
  
  public BigFluidAmount bigAdd(@Nullable FluidAmount by)
  
  Directly adds the given FluidAmount to this one, returning the result as a BigFluidAmount.
  
  Parameters:
  
  by - The amount to add. If it's null or zero then this will be returned, converted to a BigFluidAmount.
- add
  
  public BigFluidAmount add(@Nullable BigFluidAmount by)
  
  Directly adds the given BigFluidAmount to this one.
  
  Parameters:
  
  by - The amount to add. If it's null or zero then this will be returned, converted into a BigFluidAmount.
- sub
  
  public FluidAmount sub(long by)
- sub
  
  public FluidAmount sub(@Nullable FluidAmount other)
  
  The recommended method for subtracting another FluidAmount from this if you don't want to think about inexact answers.
  (Internally this calls roundedSub(FluidAmount) if you want to know the details).
  
  Parameters:
  
  other - The other FluidAmount. Null values will return "this".
- checkedSub
  
  public FluidAmount checkedSub(@Nullable FluidAmount by)
  
  Parameters:
  
  by - Either Null or a value that will be negated and then passed to checkedAdd(FluidAmount).
  
  Throws:
  
  java.lang.ArithmeticException - if the result doesn't fit into a FluidAmount.
- saturatedSub
  
  public FluidAmount saturatedSub(@Nullable FluidAmount by)
  
  Parameters:
  
  by - Either Null or a value that will be negated and then passed to saturatedAdd(FluidAmount).
- safeSub
  
  public FluidAmount.SafeAddResult safeSub(@Nullable FluidAmount by, java.math.RoundingMode rounding)
  
  Parameters:
  
  by - Either Null or a value that will be negated and then passed to safeAdd(FluidAmount, RoundingMode).
- safeSub
  
  public FluidAmount.SafeAddResult safeSub(@Nullable FluidAmount by)
  
  Parameters:
  
  by - Either Null or a value that will be negated and then passed to safeAdd(FluidAmount).
- roundedSub
  
  public FluidAmount roundedSub(@Nullable FluidAmount by, java.math.RoundingMode rounding)
  
  Parameters:
  
  by - Either Null or a value that will be negated and then passed to safeAdd(FluidAmount, RoundingMode).
  
  Returns:
  
  The FluidAmount.SafeAddResult.roundedResult.
- roundedSub
  
  public FluidAmount roundedSub(@Nullable FluidAmount by)
  
  Parameters:
  
  by - Either Null or a value that will be negated and then passed to safeAdd(FluidAmount).
  
  Returns:
  
  The FluidAmount.SafeAddResult.roundedResult.
- sub
  
  public BigFluidAmount sub(@Nullable BigFluidAmount by)
  
  Parameters:
  
  by - Either Null or a value that will be negated and then passed to add(BigFluidAmount).
- merge
  
  public static FluidAmount.FluidMergeResult merge(FluidAmount target, FluidAmount toAdd)
  
  Calls merge(FluidAmount, FluidAmount, FluidMergeRounding) with a FluidAmount.FluidMergeRounding of ROUND_HALF_EVEN.
- merge
  
  public static FluidAmount.FluidMergeResult merge(FluidAmount target, FluidAmount toAdd, FluidAmount.FluidMergeRounding rounding)
  
  Parameters:
  
  target -
  
  toAdd -
  
  rounding - The FluidAmount.FluidMergeRounding to use if the addition doesn't result in an exact FluidAmount.
  
  Returns:
- merge
  
  public static FluidAmount.FluidMergeResult merge(FluidAmount target, FluidAmount toAdd, long denominatorTarget, long denominatorAdd)
  
  Parameters:
  
  target -
  
  toAdd -
  
  denominatorTarget - The denominator that the target must be under (a multiple of it's reciprocal), or 0 if the target doesn't need to stay under a particular denominator.
  
  denominatorAdd - The denominator that the excess must be under (a multiple of it's reciprocal), or 0 if the excess doesn't need to stay under a particular denominator.
- mul
  
  public FluidAmount mul(FluidAmount by)
  
  The recommended method for multiplying two FluidAmount's together if you don't want to think about inexact answers.
  (Internally this calls roundedMul(FluidAmount) if you want to know the details).
- mul
  
  public FluidAmount mul(long by)
  
  The recommended method for multiplying this by a long if you don't want to think about inexact answers.
  (Internally this calls roundedMul(long) if you want to know the details).
- checkedMul
  
  public FluidAmount checkedMul(long by)
- saturatedMul
  
  public FluidAmount saturatedMul(long by)
- roundedMul
  
  public FluidAmount roundedMul(long by)
- roundedMul
  
  public FluidAmount roundedMul(long by, java.math.RoundingMode rounding)
- checkedMul
  
  public FluidAmount checkedMul(FluidAmount by)
- saturatedMul
  
  public FluidAmount saturatedMul(FluidAmount by)
- roundedMul
  
  public FluidAmount roundedMul(FluidAmount by)
- roundedMul
  
  public FluidAmount roundedMul(FluidAmount by, java.math.RoundingMode rounding)
- mul
  
  public BigFluidAmount mul(BigFluidAmount by)
- bigMul
  
  public BigFluidAmount bigMul(FluidAmount by)
- reciprocal
  
  public FluidAmount reciprocal()
  
  Returns:
  
  This fraction, but inverted. (With the numerator and denominator swapped).
- bigReciprocal
  
  public BigFluidAmount bigReciprocal()
- getCountOf
  
  public long getCountOf(FluidAmount by)
  
  Returns:
  
  The whole value from saturatedDiv(FluidAmount).
- div
  
  public FluidAmount div(long other)
  
  The recommended method for dividing this by a Long if you don't want to think about inexact answers.
  (Internally this calls roundedDiv(long) if you want to know the details).
- div
  
  public FluidAmount div(FluidAmount other)
  
  The recommended method for dividing this by another FluidAmount if you don't want to think about inexact answers.
  (Internally this calls roundedDiv(FluidAmount) if you want to know the details).
- checkedDiv
  
  public FluidAmount checkedDiv(long by)
- saturatedDiv
  
  public FluidAmount saturatedDiv(long by)
- roundedDiv
  
  public FluidAmount roundedDiv(long by)
- roundedDiv
  
  public FluidAmount roundedDiv(long by, java.math.RoundingMode rounding)
- checkedDiv
  
  public FluidAmount checkedDiv(FluidAmount by)
- saturatedDiv
  
  public FluidAmount saturatedDiv(FluidAmount by)
- roundedDiv
  
  public FluidAmount roundedDiv(FluidAmount by)
- roundedDiv
  
  public FluidAmount roundedDiv(FluidAmount by, java.math.RoundingMode rounding)
- div
  
  public BigFluidAmount div(BigFluidAmount by)
- bigDiv
  
  public BigFluidAmount bigDiv(FluidAmount by)
- asLongIntExact
  
  public FluidAmount asLongIntExact()
- asBigInt
  
  public BigFluidAmount asBigInt()
- isGreaterThan
  
  public boolean isGreaterThan(@Nullable FluidAmount other)
  
  Null is treated as zero
- isGreaterThanOrEqual
  
  public boolean isGreaterThanOrEqual(@Nullable FluidAmount other)
  
  Null is treated as zero
- isLessThan
  
  public boolean isLessThan(@Nullable FluidAmount other)
  
  Null is treated as zero
- isLessThanOrEqual
  
  public boolean isLessThanOrEqual(@Nullable FluidAmount other)
  
  Null is treated as zero
- gcd
  
  public BigFluidAmount gcd(FluidAmount other)
- gcd
  
  public BigFluidAmount gcd(BigFluidAmount other)
- min
  
  public FluidAmount min(FluidAmount other)
  
  Returns:
  
  The smaller of this value and then given value.
- max
  
  public FluidAmount max(FluidAmount other)
  
  Returns:
  
  The greater of this value and then given value.

Class FluidAmount

Nested Class Summary

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Details

Constructor Details

Method Details