### Create and Use Duration Instances

Source: https://context7.com/airlift/units/llms.txt

Demonstrates creating Duration instances using various units and accessing their values. Includes factory methods for succinct representation and timing elapsed operations.

```java
import io.airlift.units.Duration;
import java.util.concurrent.TimeUnit;
import static java.util.concurrent.TimeUnit.*;

// Creating Duration instances
Duration fiveSeconds = new Duration(5, SECONDS);
Duration halfHour = new Duration(30, MINUTES);
Duration twoAndHalfDays = new Duration(2.5, DAYS);
Duration precise = new Duration(1234.567, MILLISECONDS);

// Factory methods for succinct representation
Duration succinct1 = Duration.succinctNanos(1234567890L);  // Returns most readable unit
Duration succinct2 = Duration.succinctDuration(300, SECONDS); // Returns 5m

// Measuring elapsed time
long start = System.nanoTime();
// ... operation ...
Duration elapsed = Duration.nanosSince(start);             // Convenient timing helper

// Getting values
double value = fiveSeconds.getValue();                     // 5.0
double inMillis = fiveSeconds.getValue(MILLISECONDS);      // 5000.0
long roundedMillis = fiveSeconds.toMillis();               // 5000
TimeUnit unit = fiveSeconds.getUnit();                     // SECONDS

// Converting between units
Duration inMinutes = halfHour.convertTo(HOURS);            // 0.5 hours
Duration mostSuccinct = precise.convertToMostSuccinctTimeUnit();

// Converting to java.time.Duration
java.time.Duration javaDuration = fiveSeconds.toJavaTime();

// String representation
String str = fiveSeconds.toString();                       // "5.00s"
String inDays = fiveSeconds.toString(DAYS);                // "0.00d"
```

--------------------------------

### Create and Manipulate DataSize Instances

Source: https://context7.com/airlift/units/llms.txt

Demonstrates creating DataSize objects using various units, converting between them, and accessing their values. Use succinctBytes for the most human-readable representation.

```java
import io.airlift.units.DataSize;
import static io.airlift.units.DataSize.Unit.*;

// Creating DataSize instances
DataSize oneKilobyte = DataSize.of(1, KILOBYTE);           // 1kB = 1024 bytes
DataSize fiveMegabytes = DataSize.of(5, MEGABYTE);         // 5MB
DataSize rawBytes = DataSize.ofBytes(1048576);             // 1048576 bytes
DataSize succinctForm = DataSize.succinctBytes(5242880);   // Returns 5MB (most readable unit)

// Getting values
long bytes = fiveMegabytes.toBytes();                      // 5242880
double mbValue = fiveMegabytes.getValue(MEGABYTE);         // 5.0
DataSize.Unit unit = fiveMegabytes.getUnit();              // MEGABYTE

// Converting between units
DataSize inGigabytes = fiveMegabytes.to(GIGABYTE);         // Same value, different display unit
DataSize mostSuccinct = rawBytes.succinct();               // Converts to most human-readable unit (1MB)

// String representation
String str = oneKilobyte.toString();                       // "1kB"
String bytesStr = fiveMegabytes.toBytesValueString();      // "5242880B" (used for JSON)
```

--------------------------------

### DataSize and Duration Comparison and Sorting

Source: https://context7.com/airlift/units/llms.txt

Demonstrates how DataSize and Duration objects can be compared for equality and order, and how they can be used for sorting collections. Both types implement Comparable and provide proper equals and hashCode.

```java
import io.airlift.units.DataSize;
import io.airlift.units.Duration;
import static io.airlift.units.DataSize.Unit.*;
import static java.util.concurrent.TimeUnit.*;
import java.util.TreeSet;
import java.util.Arrays;
import java.util.List;

// DataSize comparison
DataSize oneKb = DataSize.of(1, KILOBYTE);
DataSize bytes1024 = DataSize.ofBytes(1024);

System.out.println(oneKb.equals(bytes1024));               // true (same byte value)
System.out.println(oneKb.compareTo(bytes1024));            // 0

DataSize twoKb = DataSize.of(2, KILOBYTE);
System.out.println(oneKb.compareTo(twoKb));                // negative (1KB < 2KB)

// Duration comparison
Duration oneMinute = new Duration(1, MINUTES);
Duration sixtySeconds = new Duration(60, SECONDS);

System.out.println(oneMinute.equals(sixtySeconds));        // true (same time value)
System.out.println(oneMinute.compareTo(sixtySeconds));     // 0

// Sorting collections
List<DataSize> sizes = Arrays.asList(
    DataSize.of(1, GIGABYTE),
    DataSize.of(500, MEGABYTE),
    DataSize.of(2, GIGABYTE)
);
sizes.sort(DataSize::compareTo);
// Result: [500MB, 1GB, 2GB]

TreeSet<Duration> durations = new TreeSet<>();
durations.add(new Duration(5, SECONDS));
durations.add(new Duration(1, MINUTES));
durations.add(new Duration(100, MILLISECONDS));
// TreeSet order: [100ms, 5s, 1m]
```

--------------------------------

### Duration Class Overview

Source: https://context7.com/airlift/units/llms.txt

Demonstrates the creation, manipulation, and conversion of Duration objects.

```APIDOC
## Duration Class

The `Duration` class represents an immutable time duration value with support for nanoseconds through days. It integrates with Java's `TimeUnit` and provides conversion to `java.time.Duration`.

### Creating Duration instances
```java
import io.airlift.units.Duration;
import java.util.concurrent.TimeUnit;
import static java.util.concurrent.TimeUnit.*;

Duration fiveSeconds = new Duration(5, SECONDS);
Duration halfHour = new Duration(30, MINUTES);
Duration twoAndHalfDays = new Duration(2.5, DAYS);
Duration precise = new Duration(1234.567, MILLISECONDS);
```

### Factory methods for succinct representation
```java
Duration succinct1 = Duration.succinctNanos(1234567890L);  // Returns most readable unit
Duration succinct2 = Duration.succinctDuration(300, SECONDS); // Returns 5m
```

### Measuring elapsed time
```java
long start = System.nanoTime();
// ... operation ...
Duration elapsed = Duration.nanosSince(start);             // Convenient timing helper
```

### Getting values
```java
double value = fiveSeconds.getValue();                     // 5.0
double inMillis = fiveSeconds.getValue(MILLISECONDS);      // 5000.0
long roundedMillis = fiveSeconds.toMillis();               // 5000
TimeUnit unit = fiveSeconds.getUnit();                     // SECONDS
```

### Converting between units
```java
Duration inMinutes = halfHour.convertTo(HOURS);            // 0.5 hours
Duration mostSuccinct = precise.convertToMostSuccinctTimeUnit();
```

### Converting to java.time.Duration
```java
java.time.Duration javaDuration = fiveSeconds.toJavaTime();
```

### String representation
```java
String str = fiveSeconds.toString();                       // "5.00s"
String inDays = fiveSeconds.toString(DAYS);                // "0.00d"
```
```

--------------------------------

### Add Units Library to Maven Project

Source: https://context7.com/airlift/units/llms.txt

Include this dependency in your pom.xml to use the DataSize and Duration classes in your Maven project.

```xml
<dependency>
    <groupId>io.airlift</groupId>
    <artifactId>units</artifactId>
    <version>1.13</version>
</dependency>
```

--------------------------------

### JSON Serialization with Jackson for DataSize and Duration

Source: https://context7.com/airlift/units/llms.txt

Demonstrates how DataSize and Duration types are serialized and deserialized using Jackson. DataSize serializes to bytes, and Duration preserves its original unit. Ensure Jackson ObjectMapper is configured correctly.

```java
import io.airlift.units.DataSize;
import io.airlift.units.Duration;
import com.fasterxml.jackson.databind.ObjectMapper;
import static io.airlift.units.DataSize.Unit.*;
import static java.util.concurrent.TimeUnit.*;

// Configuration class with Units types
public class ServerConfig {
    private DataSize maxMemory;
    private Duration timeout;

    // Getters and setters
    public DataSize getMaxMemory() { return maxMemory; }
    public void setMaxMemory(DataSize maxMemory) { this.maxMemory = maxMemory; }
    public Duration getTimeout() { return timeout; }
    public void setTimeout(Duration timeout) { this.timeout = timeout; }
}

// Serialization
ObjectMapper mapper = new ObjectMapper();
ServerConfig config = new ServerConfig();
config.setMaxMemory(DataSize.of(512, MEGABYTE));
config.setTimeout(new Duration(30, SECONDS));

String json = mapper.writeValueAsString(config);
// Output: {"maxMemory":"536870912B","timeout":"30.00s"}

// Deserialization
String inputJson = "{\"maxMemory\":\"1GB\",\"timeout\":\"5m\"}";
ServerConfig parsed = mapper.readValue(inputJson, ServerConfig.class);

System.out.println(parsed.getMaxMemory().toBytes());       // 1073741824
System.out.println(parsed.getTimeout().toMillis());        // 300000
```

--------------------------------

### Duration Time Unit Conversions

Source: https://context7.com/airlift/units/llms.txt

Details the static methods for converting between string representations and TimeUnit enum values.

```APIDOC
## Duration Time Unit Conversions

The `Duration` class provides static methods to convert between string representations and `TimeUnit` enum values.

### Convert string to TimeUnit
```java
import io.airlift.units.Duration;
import java.util.concurrent.TimeUnit;

TimeUnit ns = Duration.valueOfTimeUnit("ns");              // NANOSECONDS
TimeUnit us = Duration.valueOfTimeUnit("us");              // MICROSECONDS
TimeUnit ms = Duration.valueOfTimeUnit("ms");              // MILLISECONDS
TimeUnit s = Duration.valueOfTimeUnit("s");                // SECONDS
TimeUnit m = Duration.valueOfTimeUnit("m");                // MINUTES
TimeUnit h = Duration.valueOfTimeUnit("h");                // HOURS
TimeUnit d = Duration.valueOfTimeUnit("d");                // DAYS
```

### Convert TimeUnit to string
```java
String nsStr = Duration.timeUnitToString(TimeUnit.NANOSECONDS);   // "ns"
String usStr = Duration.timeUnitToString(TimeUnit.MICROSECONDS);  // "us"
String msStr = Duration.timeUnitToString(TimeUnit.MILLISECONDS);  // "ms"
String sStr = Duration.timeUnitToString(TimeUnit.SECONDS);        // "s"
String mStr = Duration.timeUnitToString(TimeUnit.MINUTES);        // "m"
String hStr = Duration.timeUnitToString(TimeUnit.HOURS);          // "h"
String dStr = Duration.timeUnitToString(TimeUnit.DAYS);           // "d"
```
```

--------------------------------

### Convert Between TimeUnit Strings and Enums

Source: https://context7.com/airlift/units/llms.txt

Provides static methods to convert between string representations of time units (e.g., 'ns', 's') and Java's TimeUnit enum values.

```java
import io.airlift.units.Duration;
import java.util.concurrent.TimeUnit;

// Convert string to TimeUnit
TimeUnit ns = Duration.valueOfTimeUnit("ns");              // NANOSECONDS
TimeUnit us = Duration.valueOfTimeUnit("us");              // MICROSECONDS
TimeUnit ms = Duration.valueOfTimeUnit("ms");              // MILLISECONDS
TimeUnit s = Duration.valueOfTimeUnit("s");                // SECONDS
TimeUnit m = Duration.valueOfTimeUnit("m");                // MINUTES
TimeUnit h = Duration.valueOfTimeUnit("h");                // HOURS
TimeUnit d = Duration.valueOfTimeUnit("d");                // DAYS

// Convert TimeUnit to string
String nsStr = Duration.timeUnitToString(TimeUnit.NANOSECONDS);   // "ns"
String usStr = Duration.timeUnitToString(TimeUnit.MICROSECONDS);  // "us"
String msStr = Duration.timeUnitToString(TimeUnit.MILLISECONDS);  // "ms"
String sStr = Duration.timeUnitToString(TimeUnit.SECONDS);        // "s"
String mStr = Duration.timeUnitToString(TimeUnit.MINUTES);        // "m"
String hStr = Duration.timeUnitToString(TimeUnit.HOURS);          // "h"
String dStr = Duration.timeUnitToString(TimeUnit.DAYS);           // "d"
```

--------------------------------

### Duration.valueOf - Parsing Strings

Source: https://context7.com/airlift/units/llms.txt

Explains how to parse human-readable duration strings into Duration objects using the static valueOf method.

```APIDOC
## Duration.valueOf - Parsing Strings

The `valueOf` static method parses human-readable duration strings into `Duration` objects. It supports all time unit abbreviations with or without spaces.

### Parsing strings with various formats
```java
import io.airlift.units.Duration;
import static java.util.concurrent.TimeUnit.*;

Duration parsed1 = Duration.valueOf("1234ns");             // 1234 nanoseconds
Duration parsed2 = Duration.valueOf("1234 us");            // 1234 microseconds (with space)
Duration parsed3 = Duration.valueOf("1234ms");             // 1234 milliseconds
Duration parsed4 = Duration.valueOf("30s");                // 30 seconds
Duration parsed5 = Duration.valueOf("5.5m");               // 5.5 minutes (decimal)
Duration parsed6 = Duration.valueOf("2h");                 // 2 hours
Duration parsed7 = Duration.valueOf("1d");                 // 1 day
```

### Supported unit strings
`ns`, `us`, `ms`, `s`, `m`, `h`, `d`

### Verifying parsed values
```java
Duration duration = Duration.valueOf("1234.567ms");
System.out.println(duration.getValue());                   // 1234.567
System.out.println(duration.getUnit());                    // MILLISECONDS
```

### Error handling
```java
try {
    Duration invalid = Duration.valueOf("1234 kg");        // Throws IllegalArgumentException
} catch (IllegalArgumentException e) {
    System.out.println("Unknown time unit: kg");
}
```

### Checking for zero duration
```java
Duration zero = Duration.ZERO;
System.out.println(zero.isZero());                         // true
System.out.println(Duration.valueOf("0s").isZero());       // true
```
```

--------------------------------

### Parse DataSize Strings with valueOf

Source: https://context7.com/airlift/units/llms.txt

Use the DataSize.valueOf() method to parse human-readable strings into DataSize objects. It supports various unit abbreviations, spaces, and decimal values. Ensure correct unit strings are used to avoid IllegalArgumentException.

```java
import io.airlift.units.DataSize;

// Parsing strings with various formats
DataSize parsed1 = DataSize.valueOf("1234B");              // 1234 bytes
DataSize parsed2 = DataSize.valueOf("1234 kB");            // 1234 kilobytes (with space)
DataSize parsed3 = DataSize.valueOf("1234MB");             // 1234 megabytes (no space)
DataSize parsed4 = DataSize.valueOf("1.5GB");              // 1.5 gigabytes (decimal)
DataSize parsed5 = DataSize.valueOf("100TB");              // 100 terabytes
DataSize parsed6 = DataSize.valueOf("2PB");                // 2 petabytes
DataSize parsed7 = DataSize.valueOf("1EB");                // 1 exabyte

// Supported unit strings: B, kB, MB, GB, TB, PB, EB

// Error handling
try {
    DataSize invalid = DataSize.valueOf("1234 kg");        // Throws IllegalArgumentException
} catch (IllegalArgumentException e) {
    System.out.println("Unknown unit: kg");
}

try {
    DataSize empty = DataSize.valueOf("");                 // Throws IllegalArgumentException
} catch (IllegalArgumentException e) {
    System.out.println("size is empty");
}
```

--------------------------------

### Utilize DataSize.Unit Enum Constants

Source: https://context7.com/airlift/units/llms.txt

Access binary-based unit constants (1024 multiplier) via the DataSize.Unit enum. This enum provides byte values for each unit and allows conversion between display units.

```java
import io.airlift.units.DataSize;
import io.airlift.units.DataSize.Unit;

// Available units and their byte values
long byteValue = Unit.BYTE.inBytes();                      // 1
long kbValue = Unit.KILOBYTE.inBytes();                    // 1024 (2^10)
long mbValue = Unit.MEGABYTE.inBytes();                    // 1048576 (2^20)
long gbValue = Unit.GIGABYTE.inBytes();                    // 1073741824 (2^30)
long tbValue = Unit.TERABYTE.inBytes();                    // 1099511627776 (2^40)
long pbValue = Unit.PETABYTE.inBytes();                    // 1125899906842624 (2^50)
long ebValue = Unit.EXABYTE.inBytes();                     // 1152921504606846976 (2^60)

// Get unit string representation
String unitStr = Unit.MEGABYTE.getUnitString();            // "MB"
String kbStr = Unit.KILOBYTE.getUnitString();              // "kB"

// Creating DataSize with specific units
DataSize size = DataSize.of(42, Unit.MEGABYTE);            // 42MB
System.out.println(size.toBytes());                        // 44040192

// Converting display unit
DataSize converted = size.to(Unit.KILOBYTE);
System.out.println(converted.toString());                  // "43008kB"
```

--------------------------------

### Jakarta Bean Validation Annotations for DataSize and Duration

Source: https://context7.com/airlift/units/llms.txt

Shows how to use Jakarta Bean Validation annotations like @MinDataSize, @MaxDataSize, @MinDuration, and @MaxDuration for declarative validation of DataSize and Duration fields. Ensure a ValidatorFactory and Validator are properly initialized.

```java
import io.airlift.units.DataSize;
import io.airlift.units.Duration;
import io.airlift.units.MinDataSize;
import io.airlift.units.MaxDataSize;
import io.airlift.units.MinDuration;
import io.airlift.units.MaxDuration;
import jakarta.validation.constraints.NotNull;

public class CacheConfig {
    @NotNull
    @MinDataSize("1MB")
    @MaxDataSize("10GB")
    private DataSize cacheSize;

    @NotNull
    @MinDuration("1s")
    @MaxDuration("1h")
    private Duration ttl;

    @MinDataSize("0B")
    @MaxDataSize("100MB")
    private DataSize bufferSize;

    @MinDuration("100ms")
    @MaxDuration("30s")
    private Duration connectionTimeout;

    // Getters and setters
    public DataSize getCacheSize() { return cacheSize; }
    public void setCacheSize(DataSize cacheSize) { this.cacheSize = cacheSize; }
    public Duration getTtl() { return ttl; }
    public void setTtl(Duration ttl) { this.ttl = ttl; }
    public DataSize getBufferSize() { return bufferSize; }
    public void setBufferSize(DataSize bufferSize) { this.bufferSize = bufferSize; }
    public Duration getConnectionTimeout() { return connectionTimeout; }
    public void setConnectionTimeout(Duration connectionTimeout) { this.connectionTimeout = connectionTimeout; }
}

// Usage with a validator
import jakarta.validation.Validation;
import jakarta.validation.Validator;
import jakarta.validation.ValidatorFactory;
import jakarta.validation.ConstraintViolation;
import java.util.Set;

ValidatorFactory factory = Validation.buildDefaultValidatorFactory();
Validator validator = factory.getValidator();

CacheConfig config = new CacheConfig();
config.setCacheSize(DataSize.of(500, DataSize.Unit.MEGABYTE));  // Valid: 500MB
config.setTtl(new Duration(5, java.util.concurrent.TimeUnit.MINUTES));  // Valid: 5 minutes

Set<ConstraintViolation<CacheConfig>> violations = validator.validate(config);
// violations is empty - all constraints satisfied

config.setCacheSize(DataSize.of(100, DataSize.Unit.BYTE));  // Invalid: below 1MB minimum
violations = validator.validate(config);
// violations contains: "must be greater than or equal to 1MB"
```

--------------------------------

### Parse Duration Strings with valueOf

Source: https://context7.com/airlift/units/llms.txt

Parses human-readable duration strings into Duration objects using the static valueOf method. Supports various formats and unit abbreviations. Includes error handling for invalid units.

```java
import io.airlift.units.Duration;
import static java.util.concurrent.TimeUnit.*;

// Parsing strings with various formats
Duration parsed1 = Duration.valueOf("1234ns");             // 1234 nanoseconds
Duration parsed2 = Duration.valueOf("1234 us");            // 1234 microseconds (with space)
Duration parsed3 = Duration.valueOf("1234ms");             // 1234 milliseconds
Duration parsed4 = Duration.valueOf("30s");                // 30 seconds
Duration parsed5 = Duration.valueOf("5.5m");               // 5.5 minutes (decimal)
Duration parsed6 = Duration.valueOf("2h");                 // 2 hours
Duration parsed7 = Duration.valueOf("1d");                 // 1 day

// Supported unit strings: ns, us, ms, s, m, h, d

// Verifying parsed values
Duration duration = Duration.valueOf("1234.567ms");
System.out.println(duration.getValue());                   // 1234.567
System.out.println(duration.getUnit());                    // MILLISECONDS

// Error handling
try {
    Duration invalid = Duration.valueOf("1234 kg");        // Throws IllegalArgumentException
} catch (IllegalArgumentException e) {
    System.out.println("Unknown time unit: kg");
}

// Checking for zero duration
Duration zero = Duration.ZERO;
System.out.println(zero.isZero());                         // true
System.out.println(Duration.valueOf("0s").isZero());       // true
```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.