java.lang.Object
- io.airlift.units.DataSize

All Implemented Interfaces:: Comparable<DataSize>

public final class DataSize
extends Object
implements Comparable<DataSize>

Nested Class Summary

Nested Classes
Modifier and Type Class Description

static class DataSize.Unit

Constructor Summary

Constructors
Constructor Description

DataSize(double size, DataSize.Unit unit)
Deprecated.
Use ofBytes(long) instead.

Method Summary

All Methods Static Methods Instance Methods Concrete Methods Deprecated Methods
Modifier and Type	Method	Description
`int`	`compareTo(DataSize o)`
`DataSize`	`convertTo(DataSize.Unit unit)`	Deprecated. Use `to(Unit)` instead.
`DataSize`	`convertToMostSuccinctDataSize()`	Deprecated. Use `succinct()` instead.
`boolean`	`equals(Object o)`
`DataSize.Unit`	`getUnit()`
`double`	`getValue()`	Deprecated. Use `toBytes()` instead to avoid floating point precision semantics
`double`	`getValue(DataSize.Unit unit)`	Deprecated. Use `toBytes()` instead to avoid floating point precision semantics
`int`	`hashCode()`
`static DataSize`	`of(long size, DataSize.Unit unit)`	Creates a `DataSize` instance with the provided quantity of the provided `DataSize.Unit`.
`static DataSize`	`ofBytes(long bytes)`
`long`	`roundTo(DataSize.Unit unit)`	Deprecated. Use `toBytes()` instead.
`DataSize`	`succinct()`
`static DataSize`	`succinctBytes(long bytes)`	Prefer `ofBytes(long)` when conversion to the most 'succinct' unit is not necessary or desirable
`static DataSize`	`succinctDataSize(double size, DataSize.Unit unit)`	Deprecated. use `succinctBytes(long)` instead, double values are imprecise
`DataSize`	`to(DataSize.Unit unit)`
`long`	`toBytes()`
`String`	`toBytesValueString()`
`String`	`toString()`
`static DataSize`	`valueOf(String size)`

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

- Constructor Detail
  - DataSize
```
@Deprecated
public DataSize(double size,
                DataSize.Unit unit)
```
    Deprecated.
    Use ofBytes(long) instead. The imprecise nature of using doubles for DataSize is deprecated for removal
- Method Detail
  - of
```
public static DataSize of(long size,
                          DataSize.Unit unit)
                   throws IllegalArgumentException
```
    Creates a DataSize instance with the provided quantity of the provided DataSize.Unit. This value is immediately converted to bytes which might overflow.
    
    Parameters:
    
    size - The quantity of the supplied unit
    
    unit - The unit to use as the default unit for the constructed instance and to convert the size to bytes
    
    Throws:
    
    IllegalArgumentException - If the provided size would overflow a long value when converting to bytes
  - ofBytes
```
public static DataSize ofBytes(long bytes)
```
  - succinctBytes
```
public static DataSize succinctBytes(long bytes)
```
    Prefer ofBytes(long) when conversion to the most 'succinct' unit is not necessary or desirable
  - succinctDataSize
```
@Deprecated
public static DataSize succinctDataSize(double size,
                                        DataSize.Unit unit)
```
    Deprecated.
    use succinctBytes(long) instead, double values are imprecise
    
    Prefer of(long, Unit) when conversion to the most 'succinct' unit is not necessary or desirable. Otherwise, use succinctBytes(long) since it will not incur rounding and loss of precision.
  - toBytes
```
public long toBytes()
```
  - getValue
```
@Deprecated
public double getValue()
```
    Deprecated.
    Use toBytes() instead to avoid floating point precision semantics
  - getUnit
```
public DataSize.Unit getUnit()
```
  - getValue
```
@Deprecated
public double getValue(DataSize.Unit unit)
```
    Deprecated.
    Use toBytes() instead to avoid floating point precision semantics
  - roundTo
```
@Deprecated
public long roundTo(DataSize.Unit unit)
```
    Deprecated.
    Use toBytes() instead. This method uses floating point semantics to compute the rounded value which can yield to unexpected loss of precision beyond the intended rounding
  - convertTo
```
@Deprecated
public DataSize convertTo(DataSize.Unit unit)
```
    Deprecated.
    Use to(Unit) instead. No conversion occurs when calling this method, only the unit used for the default string representation is changed. This has no effect on the unit used during JSON serialization
  - to
```
public DataSize to(DataSize.Unit unit)
```
  - succinct
```
public DataSize succinct()
```
  - convertToMostSuccinctDataSize
```
@Deprecated
public DataSize convertToMostSuccinctDataSize()
```
    Deprecated.
    Use succinct() instead. No conversion occurs when calling this method, only the unit used for the default string representation is changed. This has no effect on the unit used during JSON serialization
  - toBytesValueString
```
public String toBytesValueString()
```
  - toString
```
public String toString()
```
    Overrides:
    
    toString in class Object
  - valueOf
```
public static DataSize valueOf(String size)
                        throws IllegalArgumentException
```
    Throws:
    
    IllegalArgumentException
  - compareTo
```
public int compareTo(DataSize o)
```
    Specified by:
    
    compareTo in interface Comparable<DataSize>
  - equals
```
public boolean equals(Object o)
```
    Overrides:
    
    equals in class Object
  - hashCode
```
public int hashCode()
```
    Overrides:
    
    hashCode in class Object

Class DataSize

Nested Class Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

DataSize

Method Detail

of

ofBytes

succinctBytes

succinctDataSize

toBytes

getValue

getUnit

getValue

roundTo

convertTo

to

succinct

convertToMostSuccinctDataSize

toBytesValueString

toString

valueOf

compareTo

equals

hashCode