### Custom ProgressBarRenderer Implementation

Source: https://context7.com/ctongfei/progressbar/llms.txt

Implement ProgressBarRenderer to define a custom string format for progress states. This example shows how to create a renderer that displays the task name, percentage completion, current/max values, and an extra message. Ensure the ProgressBar is built with this custom renderer and used within a try-with-resources block for proper management.

```java
ProgressBarRenderer myRenderer = state -> {
    long pct = state.getMax() > 0
            ? state.getCurrent() * 100 / state.getMax()
            : -1;
    return String.format("[%s] %d%% (%d/%d) %s",
            state.getTaskName(), pct,
            state.getCurrent(), state.getMax(),
            state.getExtraMessage());
};

try (ProgressBar pb = ProgressBar.builder()
        .setTaskName("Custom Render")
        .setInitialMax(40)
        .setRenderer(myRenderer)
        .build()) {
    for (int i = 0; i < 40; i++) {
        pb.step();
        pb.setExtraMessage("item-" + i);
        Thread.sleep(50);
    }
}
// Output: [Custom Render] 50% (20/40) item-19
```

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

### Import Progressbar Library in Java

Source: https://github.com/ctongfei/progressbar/blob/main/docs/index.md

Import the necessary class from the Progressbar library to start using its features in your Java code.

```java
import me.tongfei.progressbar.*;
```

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

### Multiple Progress Bars for Parallel Jobs

Source: https://github.com/ctongfei/progressbar/blob/main/README.md

Demonstrates how to manage multiple progress bars concurrently within a single try-with-resource block, suitable for tracking parallel tasks.

```java
try (ProgressBar pb1 = new ProgressBar("Job1", max1); 
     ProgressBar pb2 = new ProgressBar("Job2", max2)) { ... }
```

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

### Customize ProgressBar with Builder

Source: https://github.com/ctongfei/progressbar/blob/main/docs/builder.md

Use the builder pattern to configure a `ProgressBar` with various optional settings like initial max, style, task name, units, update interval, and rendered length. The `showSpeed()` method can be used to display progress speed, with an option to customize its format. An ETA function can also be provided to estimate remaining time.

```java
ProgressBarBuilder pbb = ProgressBar.builder()
    .setInitialMax(<initial max>)
    .setStyle(ProgressBarStyle.<style>)
    .setTaskName(<taskName name>)
    .setUnit(<unit name>, <unit size>)
    .setUpdateIntervalMillis(<update interval>)
    .setMaxRenderedLength(<max rendered length in terminal>)
    .showSpeed();
  // or .showSpeed(new DecimalFormat("#..##")) to customize speed display
    .setEtaFunction(state -> ...)
  // This function is of type `ProgressState -> Optional<Duration>` 
  // that should output the estimated ETA of the progress.
  // Returning `Optional.empty()` means that ETA is not available.
for (T x : ProgressBar.wrap(collection, pbb)) {
    ...
```

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

### Imperative Progressbar Usage with Try-With-Resources

Source: https://github.com/ctongfei/progressbar/blob/main/docs/imperative-usage.md

Use this pattern for imperative control over progress bars, ensuring safe termination via try-with-resources. It supports manual updates like stepping, setting specific progress points, and adjusting the maximum value or extra messages during execution.

```java
try (ProgressBar pb = new ProgressBar("Test", 100)) { // name, initial max
 // Use ProgressBar("Test", 100, ProgressBarStyle.ASCII) if you want ASCII output style
  for (T x : collection) {
    ...
    pb.step(); // step by 1
    pb.stepBy(n); // step by n
    ...
    pb.stepTo(n); // step directly to n
    ...
    pb.maxHint(n);
    // reset the max of this progress bar as n. This may be useful when the program
    // gets new information about the current progress.
    // Can set n to be less than zero: this means that this progress bar would become
    // indefinite: the max would be unknown.
    ...
    pb.setExtraMessage("Reading..."); // Set extra message to display at the end of the bar
  }
} // progress bar stops automatically after completion of try-with-resource block
```

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

### Basic Declarative Usage Syntax

Source: https://github.com/ctongfei/progressbar/blob/main/docs/declarative-usage.md

The fundamental syntax for wrapping a collection or stream with ProgressBar. The task name is provided as the second argument.

```java
ProgressBar.wrap(collection, taskName)
```

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

### Add ProgressBar Dependency

Source: https://context7.com/ctongfei/progressbar/llms.txt

Include the ProgressBar library in your project using Maven or Gradle.

```xml
<dependency>
    <groupId>me.tongfei</groupId>
    <artifactId>progressbar</artifactId>
    <version>0.10.2</version>
</dependency>
```

```groovy
compile 'me.tongfei:progressbar:0.10.2'
```

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

### Wrapping I/O Streams

Source: https://context7.com/ctongfei/progressbar/llms.txt

The `ProgressBar.wrap()` method can be used to track the progress of I/O operations on streams.

```APIDOC
## Wrapping I/O Streams

`ProgressBar.wrap(...)` detects `FileInputStream` automatically to read the file size and set the max, showing bytes/MiB/GiB as the unit.

### Usage Examples

#### Wrapping an InputStream

```java
File f = new File("large-dataset.bin");
ProgressBarBuilder pbb = ProgressBar.builder()
        .setTaskName("Reading")
        .setUnit("MiB", 1_048_576);

try (InputStream raw = ProgressBar.wrap(new FileInputStream(f), pbb);
     Reader reader = new BufferedReader(new InputStreamReader(raw))) {
    String line;
    while ((line = ((BufferedReader) reader).readLine()) != null) {
        process(line);
    }
}
```

#### Wrapping an OutputStream

```java
try (OutputStream out = ProgressBar.wrap(
        new FileOutputStream("output.bin"), "Writing")) {
    for (byte[] chunk : dataChunks) {
        out.write(chunk);
    }
}
```

#### Wrapping a Reader

```java
try (Reader tracked = ProgressBar.wrap(
        new FileReader("notes.txt"), "Scanning")) {
    int ch;
    while ((ch = tracked.read()) != -1) { /* process */ }
}
```
```

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

### Imperative Progress Bar Usage with try-with-resource

Source: https://github.com/ctongfei/progressbar/blob/main/README.md

Use the try-with-resource block for imperative control over a progress bar. This ensures the progress bar is properly managed and stopped. Supports manual stepping and setting maximum values.

```java
// try-with-resource block
try (ProgressBar pb = new ProgressBar("Test", 100)) { // name, initial max
 // Use ProgressBar("Test", 100, ProgressBarStyle.ASCII) if you want ASCII output style
  for ( /* TASK TO TRACK */ ) {
    pb.step(); // step by 1
    pb.stepBy(n); // step by n
    ...
    pb.stepTo(n); // step directly to n
    ...
    pb.maxHint(n);
    // reset the max of this progress bar as n. This may be useful when the program
    // gets new information about the current progress.
    // Can set n to be less than zero: this means that this progress bar would become
    // indefinite: the max would be unknown.
    ...
    pb.setExtraMessage("Reading..."); // Set extra message to display at the end of the bar
  }
} // progress bar stops automatically after completion of try-with-resource block
```

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

### Configure ProgressBar with Builder API

Source: https://context7.com/ctongfei/progressbar/llms.txt

Use ProgressBarBuilder for full configuration. It allows setting task names, initial maximum values, styles, update intervals, speed display, ETA functions, and more. Can be used with declarative wrapping or imperative building.

```java
ProgressBarBuilder pbb = ProgressBar.builder()
    .setTaskName("Importing")
    .setInitialMax(50_000)
    .setStyle(ProgressBarStyle.ASCII)           // ASCII rendering
    .setUnit("rows", 1)                         // unit label and size
    .setUpdateIntervalMillis(500)               // refresh every 500 ms
    .continuousUpdate()                         // redraw even without step
    .showSpeed()                                // show rows/s
    .showSpeed(new DecimalFormat("#.##"))        // custom speed format
    .setSpeedUnit(ChronoUnit.MINUTES)           // rows/min instead
    .setMaxRenderedLength(80)                   // cap rendered width
    .clearDisplayOnFinish()                     // erase bar when done
    .startsFrom(1000, Duration.ofSeconds(5))    // resume mid-progress
    .setEtaFunction(state ->                    // custom ETA function
        state.getMax() > 0
            ? Optional.of(Duration.ofSeconds((state.getMax() - state.getCurrent()) / 10))
            : Optional.empty()
    )
    .hideEta();                                 // or suppress ETA entirely

// Use with declarative wrapping:
for (MyRecord r : ProgressBar.wrap(records, pbb)) {
    process(r);
}

// Or build imperatively:
try (ProgressBar pb = pbb.build()) {
    pb.stepTo(25_000);
    pb.setExtraMessage("halfway");
}
```

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

### Utilize Built-in ProgressBarStyle Options

Source: https://context7.com/ctongfei/progressbar/llms.txt

Choose from four built-in styles for progress bar rendering: COLORFUL_UNICODE_BLOCK, COLORFUL_UNICODE_BAR, UNICODE_BLOCK, and ASCII. Apply a style using the ProgressBarBuilder.

```java
// Built-in styles
ProgressBarStyle.COLORFUL_UNICODE_BLOCK  // default — colored Unicode blocks
ProgressBarStyle.COLORFUL_UNICODE_BAR    // colored Unicode bar (━╸╺)
ProgressBarStyle.UNICODE_BLOCK           // monochrome Unicode blocks
ProgressBarStyle.ASCII                   // pure ASCII [===>  ]
```

```java
// Use a built-in style via the builder
try (ProgressBar pb = ProgressBar.builder()
        .setTaskName("ASCII Task")
        .setInitialMax(100)
        .setStyle(ProgressBarStyle.ASCII)
        .build()) {
    for (int i = 0; i < 100; i++) pb.step();
}
// Output: ASCII Task [=========>          ] 50/100
```

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

### Wrap I/O Streams for Progress Tracking

Source: https://context7.com/ctongfei/progressbar/llms.txt

Use `ProgressBar.wrap()` to automatically track progress for `FileInputStream`, `FileOutputStream`, and `Reader` operations. For streams, the maximum is set from the file size, displaying units like bytes/MiB/GiB.

```java
// Track reading a file — max set automatically from file size
File f = new File("large-dataset.bin");
ProgressBarBuilder pbb = ProgressBar.builder()
        .setTaskName("Reading")
        .setUnit("MiB", 1_048_576);

try (InputStream raw = ProgressBar.wrap(new FileInputStream(f), pbb);
     Reader reader = new BufferedReader(new InputStreamReader(raw))) {
    String line;
    while ((line = ((BufferedReader) reader).readLine()) != null) {
        process(line);
    }
}
// Output: Reading |████████████░░░░░░| 128/256 MiB ETA 00:00:04
```

```java
// Track writing to an OutputStream
try (OutputStream out = ProgressBar.wrap(
        new FileOutputStream("output.bin"), "Writing")) {
    for (byte[] chunk : dataChunks) {
        out.write(chunk);
    }
}
```

```java
// Track a Reader
try (Reader tracked = ProgressBar.wrap(
        new FileReader("notes.txt"), "Scanning")) {
    int ch;
    while ((ch = tracked.read()) != -1) { /* process */ }
}
```

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

### Integrate Progress Bar with SLF4j Logger

Source: https://github.com/ctongfei/progressbar/blob/main/docs/loggers.md

Use `DelegatingProgressBarConsumer` with a logger method passed as a lambda to integrate the progress bar with SLF4j. Ensure the logger is created using `LoggerFactory.getLogger()`.

```java
    // create logger using slf4j
    final Logger logger = LoggerFactory.getLogger("Test");

    try (ProgressBar pb = new ProgressBarBuilder()
            .setInitialMax(100)
            .setTaskName("Test")
            .setConsumer(new DelegatingProgressBarConsumer(logger::info))
            .build()) {
        // your taskName here
    }
```

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

### Logger Integration

Source: https://context7.com/ctongfei/progressbar/llms.txt

Integrate ProgressBar output with a logger (e.g., SLF4J) using `DelegatingProgressBarConsumer`.

```APIDOC
## Logger Integration — `DelegatingProgressBarConsumer`

Routes progress bar output through any logger (e.g., SLF4J) instead of writing directly to stderr.

### Usage Example

```java
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

Logger logger = LoggerFactory.getLogger("Progress");

try (ProgressBar pb = ProgressBar.builder()
        .setTaskName("ETL")
        .setInitialMax(1000)
        .setConsumer(new DelegatingProgressBarConsumer(logger::info))
        .build()) {
    for (int i = 0; i < 1000; i++) {
        pb.step();
        Thread.sleep(5);
    }
}

// Custom consumer width
try (ProgressBar pb = ProgressBar.builder()
        .setTaskName("Batch")
        .setInitialMax(500)
        .setConsumer(new DelegatingProgressBarConsumer(logger::debug, 120))
        .build()) {
    for (int i = 0; i < 500; i++) pb.step();
}
```

### `DelegatingProgressBarConsumer` Constructor

- `DelegatingProgressBarConsumer(Consumer<String> consumer)`: Creates a consumer that delegates to the provided consumer function.
- `DelegatingProgressBarConsumer(Consumer<String> consumer, int maxWidth)`: Creates a consumer with a specified maximum width for the output.
```

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

### Imperative Usage: Manual Stepping

Source: https://context7.com/ctongfei/progressbar/llms.txt

Manually control progress bar updates using `step()`, `stepBy(n)`, or `stepTo(n)`. Use try-with-resources for clean shutdown.

```java
// Basic imperative usage
try (ProgressBar pb = new ProgressBar("Download", 100)) {
    for (int i = 0; i < 100; i++) {
        Thread.sleep(50);
        pb.step();                         // advance by 1
        pb.setExtraMessage("item " + i);   // trailing status text
    }
}
```

```java
// step(), stepBy(n), stepTo(n)
try (ProgressBar pb = new ProgressBar("Upload", 500)) {
    pb.stepTo(50);   // jump directly to 50
    pb.stepBy(100);  // advance by 100 → now at 150
    pb.step();       // advance by 1   → now at 151

    pb.maxHint(1000); // extend max dynamically when total becomes known
    pb.maxHint(-1);   // switch to indefinite mode

    System.out.println(pb.getCurrent());            // 151
    System.out.println(pb.getMax());                // 1000
    System.out.println(pb.getNormalizedProgress()); // 0.151
    System.out.println(pb.getTotalElapsed());        // Duration
}
```

```java
// Pause and resume
try (ProgressBar pb = new ProgressBar("Pausable", 200)) {
    for (int i = 0; i < 100; i++) { pb.step(); }
    pb.pause();
    Thread.sleep(500); // paused time is excluded from ETA/speed
    pb.resume();
    for (int i = 0; i < 100; i++) { pb.step(); }
}
```

```java
// Reset
try (ProgressBar pb = new ProgressBar("Retryable", 50)) {
    for (int i = 0; i < 50; i++) { pb.step(); }
    pb.reset(); // back to 0 — useful for multi-pass loops
    for (int i = 0; i < 50; i++) { pb.step(); }
}
```

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

### Route ProgressBar Output via Logger

Source: https://context7.com/ctongfei/progressbar/llms.txt

Integrate ProgressBar with logging frameworks like SLF4J using `DelegatingProgressBarConsumer`. This routes progress bar output to a specified logger method (e.g., `logger::info`) instead of stderr. Custom consumer width can also be set.

```java
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

Logger logger = LoggerFactory.getLogger("Progress");

try (ProgressBar pb = ProgressBar.builder()
        .setTaskName("ETL")
        .setInitialMax(1000)
        .setConsumer(new DelegatingProgressBarConsumer(logger::info))
        .build()) {
    for (int i = 0; i < 1000; i++) {
        pb.step();
        Thread.sleep(5);
    }
}
// Each refresh emits a log line at INFO level:
// [INFO] ETL |████████░░░░░░░░| 500/1000 ETA 00:00:02
```

```java
// Custom consumer width
try (ProgressBar pb = ProgressBar.builder()
        .setTaskName("Batch")
        .setInitialMax(500)
        .setConsumer(new DelegatingProgressBarConsumer(logger::debug, 120))
        .build()) {
    for (int i = 0; i < 500; i++) pb.step();
}
```

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

### ProgressBarStyle

Source: https://context7.com/ctongfei/progressbar/llms.txt

Defines the visual styles for the progress bar, including built-in options and a builder for custom styles.

```APIDOC
## ProgressBarStyle

Four built-in styles plus a fully custom style builder are available.

### Built-in Styles

- `ProgressBarStyle.COLORFUL_UNICODE_BLOCK` (default)
- `ProgressBarStyle.COLORFUL_UNICODE_BAR`
- `ProgressBarStyle.UNICODE_BLOCK`
- `ProgressBarStyle.ASCII`

### Custom Style Builder

`ProgressBarStyle.builder()` allows creating custom styles.

#### Methods

- **colorCode(byte code)**: Sets the ANSI color code.
- **leftBracket(String bracket)**: Sets the left bracket character.
- **rightBracket(String bracket)**: Sets the right bracket character.
- **block(char block)**: Sets the character used for the progress block.
- **rightSideFractionSymbol(char symbol)**: Sets the symbol for the right side of the fraction.
- **build()**: Builds and returns a ProgressBarStyle instance.

### Usage Example

```java
// Using a built-in style
try (ProgressBar pb = ProgressBar.builder()
        .setTaskName("ASCII Task")
        .setInitialMax(100)
        .setStyle(ProgressBarStyle.ASCII)
        .build()) {
    // ...
}

// Using a custom style
ProgressBarStyle custom = ProgressBarStyle.builder()
        .colorCode((byte) 33) // ANSI yellow
        .leftBracket("{")
        .rightBracket("}")
        .block('-')
        .rightSideFractionSymbol('+')
        .build();

try (ProgressBar pb = ProgressBar.builder()
        .setTaskName("Custom")
        .setInitialMax(80)
        .setStyle(custom)
        .build()) {
    // ...
}
```
```

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

### Declarative Progress Bar Usage with Collections

Source: https://github.com/ctongfei/progressbar/blob/main/README.md

Wrap a collection with ProgressBar.wrap() for automatic progress monitoring during iteration. This is a concise way to add progress bars to loops.

```java
// Looping over a collection:
for (T x : ProgressBar.wrap(collection, "TaskName")) {
    ...
    // Progress will be automatically monitored by a progress bar
}
```

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

### Add progressbar Dependency to Maven Project

Source: https://github.com/ctongfei/progressbar/blob/main/README.md

Include this XML snippet in your Maven project's pom.xml to add the progressbar library as a dependency. Replace $VERSION with the latest version available.

```xml
<dependency>
      <groupId>me.tongfei</groupId>
      <artifactId>progressbar</artifactId>
      <version>$VERSION</version>
  </dependency>
```

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

### Declarative Usage: Wrap Collections and Streams

Source: https://context7.com/ctongfei/progressbar/llms.txt

Automatically track progress by wrapping collections, streams, arrays, or IO objects. The bar size is inferred or indefinite.

```java
List<String> items = List.of("alpha", "beta", "gamma", "delta");

// Wrap a collection — max is set automatically from collection size
for (String item : ProgressBar.wrap(items, "Processing")) {
    Thread.sleep(200); // simulate work
}
// Output: Processing |████████████████████| 4/4 (100%) 0.8s
```

```java
// Wrap a Java Stream (sequential or parallel)
long count = ProgressBar.wrap(
        IntStream.range(0, 1000).parallel(), "Parallel Task"
    ).filter(i -> i % 2 == 0)
     .count();
```

```java
// Wrap an array
String[] array = {"a", "b", "c"};
ProgressBar.wrap(array, "Array Task").forEach(s -> { /* work */ });
```

```java
// Wrap an Iterator (indefinite bar — size unknown)
Iterator<String> it = items.iterator();
Iterator<String> tracked = ProgressBar.wrap(it, "Iterator Task");
while (tracked.hasNext()) {
    String s = tracked.next();
}
```

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

### Create Custom ProgressBarStyle

Source: https://context7.com/ctongfei/progressbar/llms.txt

Define a custom progress bar style using `ProgressBarStyle.builder()`. Configure ANSI color codes, brackets, and block characters. This requires version 0.10.0 or later.

```java
// Custom style via ProgressBarStyleBuilder (since 0.10.0)
ProgressBarStyle custom = ProgressBarStyle.builder()
        .colorCode((byte) 33)          // ANSI yellow
        .leftBracket("{")
        .rightBracket("}")
        .block('-')
        .rightSideFractionSymbol('+')
        .build();

try (ProgressBar pb = ProgressBar.builder()
        .setTaskName("Custom")
        .setInitialMax(80)
        .setStyle(custom)
        .build()) {
    for (int i = 0; i < 80; i++) pb.step();
}
// Output: Custom {----------------+       } 40/80
```

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

### Multiple Concurrent Progress Bars

Source: https://context7.com/ctongfei/progressbar/llms.txt

Run multiple ProgressBar instances simultaneously, each on its own terminal line. Uses `ExecutorService` for concurrent execution.

```java
int max1 = 200, max2 = 500;

try (ProgressBar pb1 = new ProgressBar("Job 1", max1);
     ProgressBar pb2 = new ProgressBar("Job 2", max2)) {

    ExecutorService exec = Executors.newFixedThreadPool(2);
    exec.submit(() -> { for (int i = 0; i < max1; i++) { pb1.step(); sleep(10); } });
    exec.submit(() -> { for (int i = 0; i < max2; i++) { pb2.step(); sleep(4);  } });
    exec.shutdown();
    exec.awaitTermination(1, TimeUnit.MINUTES);
}
// Output (two live lines):
// Job 1 |████████░░░░░░░░░░| 120/200 ETA 00:00:08
// Job 2 |████████░░░░░░░░░░| 300/500 ETA 00:00:08
```

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

### Declarative Usage with Builder Pattern

Source: https://github.com/ctongfei/progressbar/blob/main/docs/declarative-usage.md

Customize ProgressBar behavior by using the builder pattern before wrapping a collection or stream. This allows for advanced configuration options.

```java
ProgressBarBuilder pbb = new ProgressBarBuilder()
    .setXXX().setYYY();  // setting the builder
ProgressBar.wrap(iterable, pbb)
```

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

### Gradle Dependency for Progressbar

Source: https://github.com/ctongfei/progressbar/blob/main/docs/index.md

Add this dependency to your Gradle project to include the Progressbar library.

```groovy
compile 'me.tongfei:progressbar:$VERSION'
```

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

### Maven Dependency for Progressbar

Source: https://github.com/ctongfei/progressbar/blob/main/docs/index.md

Add this dependency to your Maven project to include the Progressbar library.

```xml
<dependency>
        <groupId>me.tongfei</groupId>
        <artifactId>progressbar</artifactId>
        <version>$VERSION</version>
    </dependency>
```

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

### Wrap a Java Collection

Source: https://github.com/ctongfei/progressbar/blob/main/docs/declarative-usage.md

Wrap a collection to display progress during iteration. The progress bar's maximum value is automatically set if the collection's size is known; otherwise, it remains indefinite.

```java
for (T x : ProgressBar.wrap(collection, "Traversing")) {
    ...
}
```

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

### Wrap a Java Stream

Source: https://github.com/ctongfei/progressbar/blob/main/docs/declarative-usage.md

Track progress for sequential or parallel Java streams using ProgressBar.wrap. This feature is available since version 0.7.2.

```java
ProgressBar.wrap(IntStream.range(left, right).parallel(), "Task").forEach(i -> {
        ...
    });
```

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

### Wrap an InputStream with Custom Units

Source: https://github.com/ctongfei/progressbar/blob/main/docs/declarative-usage.md

Read a file lazily while displaying progress in MiB. The ProgressBarBuilder is used to set the task name and unit. If the InputStream is a FileInputStream, its size is used to set the progress bar's maximum.

```java
ProgressBarBuilder pbb = new ProgressBarBuilder()
    .setTaskName("Reading")
    .setUnit("MiB", 1048576); // setting the progress bar to use MiB as the unit

try (Reader reader = new BufferedReader(new InputStreamReader(
        ProgressBar.wrap(new FileInputStream(f), pbb)
    ))) 
{
    ...
}
```

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

### ProgressBarBuilder API

Source: https://context7.com/ctongfei/progressbar/llms.txt

The ProgressBarBuilder provides a fluent API for configuring progress bar behavior and appearance. You can set task names, initial maximum values, visual styles, update intervals, and more.

```APIDOC
## ProgressBarBuilder

`ProgressBarBuilder` (also accessible via `ProgressBar.builder()`) provides the full configuration surface for a progress bar.

### Methods

- **setTaskName(String name)**: Sets the name of the task.
- **setInitialMax(long max)**: Sets the initial maximum value for the progress bar.
- **setStyle(ProgressBarStyle style)**: Sets the visual style of the progress bar.
- **setUnit(String unit, int size)**: Sets the unit label and size for progress display.
- **setUpdateIntervalMillis(long millis)**: Sets the interval in milliseconds for updating the progress bar display.
- **continuousUpdate()**: Enables continuous redrawing of the progress bar even without step updates.
- **showSpeed()**: Enables displaying the speed of progress.
- **showSpeed(DecimalFormat format)**: Enables displaying the speed with a custom format.
- **setSpeedUnit(ChronoUnit unit)**: Sets the unit for speed display (e.g., ChronoUnit.MINUTES).
- **setMaxRenderedLength(int length)**: Caps the maximum rendered width of the progress bar.
- **clearDisplayOnFinish()**: Clears the progress bar display upon completion.
- **startsFrom(long current, Duration duration)**: Resumes progress from a specified value and time.
- **setEtaFunction(Function<State, Optional<Duration>> etaFunction)**: Sets a custom function to calculate the Estimated Time of Arrival (ETA).
- **hideEta()**: Hides the ETA display.
- **build()**: Builds and returns a ProgressBar instance.

### Usage Example

```java
ProgressBarBuilder pbb = ProgressBar.builder()
    .setTaskName("Importing")
    .setInitialMax(50_000)
    .setStyle(ProgressBarStyle.ASCII)
    .setUnit("rows", 1)
    .setUpdateIntervalMillis(500)
    .continuousUpdate()
    .showSpeed()
    .setSpeedUnit(ChronoUnit.MINUTES)
    .setMaxRenderedLength(80)
    .clearDisplayOnFinish()
    .startsFrom(1000, Duration.ofSeconds(5));

try (ProgressBar pb = pbb.build()) {
    // Use the progress bar
}
```
```

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

### Customize Progress Bar Style with Builder

Source: https://github.com/ctongfei/progressbar/blob/main/docs/styles.md

Since version 0.10.0, you can create a custom progress bar style using a builder. This allows for fine-grained control over elements like color codes, brackets, block characters, and symbols.

```java
ProgressBarBuilder pbb = ProgressBar.builder()
    // ...
    .setStyle(ProgressBarStyle.builder()
                      .colorCode((byte) 33)  // the ANSI color code
                      .leftBracket("{")
                      .rightBracket("}")
                      .block('-')
                      .rightSideFractionSymbol('+')
                      .build()
   )
   // ...

```

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

### Set Progress Bar Style with Enum

Source: https://github.com/ctongfei/progressbar/blob/main/docs/styles.md

Use the setStyle method on a ProgressBarBuilder to apply one of the predefined visual styles (e.g., COLORFUL_UNICODE_BLOCK).

```java
ProgressBarBuilder pbb = new ProgressBarBuilder()
    .setStyle(ProgressBarStyle.<STYLE>);
```

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