ReadOnlyDecimalFloat (Artio)

java.lang.Object
- uk.co.real_logic.artio.fields.ReadOnlyDecimalFloat

All Implemented Interfaces:

java.lang.Comparable<ReadOnlyDecimalFloat>

Direct Known Subclasses:

DecimalFloat
```
public class ReadOnlyDecimalFloat
extends java.lang.Object
implements java.lang.Comparable<ReadOnlyDecimalFloat>
```
The main purpose of this class is to prevent accidental mutation of predefined constant values such as ZERO. An additional benefit is that it can be used to specify an argument of a function that promises not to modify the input value. The class is prefixed with ReadOnly, not with Immutable. It can still reference a mutable DecimalFloat subclass. This should be sufficient, as the ReadOnlyDecimalFloat type guarantees the following: - holders of the reference to the ReadOnlyDecimalFloat type do not modify its value even if the underlying implementation is mutable - immutability, when using a predefined constants or when obtained using DecimalFloat.immutableCopy()

Field Summary

Fields
Modifier and Type	Field and Description
`static ReadOnlyDecimalFloat`	`MAX_VALUE`
`static ReadOnlyDecimalFloat`	`MIN_VALUE`
`static ReadOnlyDecimalFloat`	`MISSING_FLOAT`
`static ReadOnlyDecimalFloat`	`NAN`
`protected int`	`scale`
`protected long`	`value`
`static ReadOnlyDecimalFloat`	`ZERO`

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`appendTo(java.lang.StringBuilder builder)`
`int`	`compareTo(ReadOnlyDecimalFloat other)`
`boolean`	`equals(java.lang.Object o)` This method should satisfy the Effective Java - 3rd Edition - Methods Common to All Objects Item 10 "Obey the general contract when overriding equals", and it should do it for every x and y where x and y can be an instance of ReadOnlyDecimalFloat or DecimalFloat, in any order, this method is: Reflexive : x.equal(x) return true Symmetric : if x.equals(y) return true, y.equals(x) return true Transitive : if x.equals(y) return true and y.equals(z) return true, x.equals(z) return true Consistent : invocations of x.equals(y) return the same value For any x != null, x.equals(null) returns false Support for DecimalFloat was done to provide a backward compatibility when some constants such as ZERO or NAN were made read only to avoid subtle bugs.
`int`	`hashCode()`
`boolean`	`isNaNValue()`
`static boolean`	`isNaNValue(long value, int scale)`
`DecimalFloat`	`mutableCopy()`
`int`	`scale()` Get the number of digits to the right of the decimal point.
`protected void`	`setAndNormalise(long value, int scale)`
`double`	`toDouble()`
`java.lang.String`	`toString()`
`long`	`value()`

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

- Field Detail
  - MIN_VALUE
```
public static final ReadOnlyDecimalFloat MIN_VALUE
```
  - MAX_VALUE
```
public static final ReadOnlyDecimalFloat MAX_VALUE
```
  - ZERO
```
public static final ReadOnlyDecimalFloat ZERO
```
  - NAN
```
public static final ReadOnlyDecimalFloat NAN
```
  - MISSING_FLOAT
```
public static final ReadOnlyDecimalFloat MISSING_FLOAT
```
  - value
```
protected long value
```
  - scale
```
protected int scale
```
- Method Detail
  - mutableCopy
```
public DecimalFloat mutableCopy()
```
    Returns:
    
    The same value, but with the type that allows mutations.
  - isNaNValue
```
public boolean isNaNValue()
```
  - toDouble
```
public double toDouble()
```
  - isNaNValue
```
public static boolean isNaNValue(long value,
                                 int scale)
```
  - value
```
public long value()
```
  - scale
```
public int scale()
```
    Get the number of digits to the right of the decimal point.
    
    Returns:
    
    the number of digits to the right of the decimal point.
  - appendTo
```
public void appendTo(java.lang.StringBuilder builder)
```
  - toString
```
public java.lang.String toString()
```
    Overrides:
    
    toString in class java.lang.Object
  - compareTo
```
public final int compareTo(ReadOnlyDecimalFloat other)
```
    Specified by:
    
    compareTo in interface java.lang.Comparable<ReadOnlyDecimalFloat>
  - equals
```
public final boolean equals(java.lang.Object o)
```
    This method should satisfy the Effective Java - 3rd Edition - Methods Common to All Objects Item 10 "Obey the general contract when overriding equals", and it should do it for every x and y where x and y can be an instance of ReadOnlyDecimalFloat or DecimalFloat, in any order, this method is: Reflexive : x.equal(x) return true Symmetric : if x.equals(y) return true, y.equals(x) return true Transitive : if x.equals(y) return true and y.equals(z) return true, x.equals(z) return true Consistent : invocations of x.equals(y) return the same value For any x != null, x.equals(null) returns false Support for DecimalFloat was done to provide a backward compatibility when some constants such as ZERO or NAN were made read only to avoid subtle bugs. By making DecimalFloats equal the corresponding ReadOnlyDecimalFloat any code that used the predefined constants when they were mutable should still yield the same results, thus avoiding a different class of subtle errors if the client code was not thoroughly tested
    
    Overrides:
    
    equals in class java.lang.Object
    
    Parameters:
    
    o - object to compare with
    
    Returns:
    
    true if any combination of ReadOnlyDecimalFloat or DecimalFloat is equal each other
  - hashCode
```
public final int hashCode()
```
    Overrides:
    
    hashCode in class java.lang.Object
  - setAndNormalise
```
protected final void setAndNormalise(long value,
                                     int scale)
```

Class ReadOnlyDecimalFloat

Field Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

MIN_VALUE

MAX_VALUE

ZERO

NAN

MISSING_FLOAT

value

scale

Method Detail

mutableCopy

isNaNValue

toDouble

isNaNValue

value

scale

appendTo

toString

compareTo

equals

hashCode

setAndNormalise