org.apache.commons.io.input

## Class Tailer

- java.lang.Object
- - org.apache.commons.io.input.Tailer

- All Implemented Interfaces:
    AutoCloseable, Runnable

      public class Tailer
      extends Object
      implements Runnable, AutoCloseable

  Simple implementation of the Unix "tail -f" functionality.

  To build an instance, use `Tailer.Builder`.

  ## 1. Create a TailerListener implementation

  First you need to create a `TailerListener` implementation; (`TailerListenerAdapter` is provided for convenience so that you don't have to implement every method).

  For example:

       public class MyTailerListener extends TailerListenerAdapter {
           public void handle(String line) {
               System.out.println(line);
           }
       }

  ## 2. Using a Tailer

  You can create and use a Tailer in one of three ways:

  - Using a `Tailer.Builder`
  - Using an `Executor`
  - Using a `Thread`

  An example of each is shown below.

  ### 2.1 Using a Builder

       TailerListener listener = new MyTailerListener();
       Tailer tailer = Tailer.builder()
         .setFile(file)
         .setTailerListener(listener)
         .setDelayDuration(delay)
         .get();

  ### 2.2 Using an Executor

       TailerListener listener = new MyTailerListener();
       Tailer tailer = new Tailer(file, listener, delay);

       // stupid executor impl. for demo purposes
       Executor executor = new Executor() {
           public void execute(Runnable command) {
               command.run();
           }
       };

       executor.execute(tailer);

  ### 2.3 Using a Thread

       TailerListener listener = new MyTailerListener();
       Tailer tailer = new Tailer(file, listener, delay);
       Thread thread = new Thread(tailer);
       thread.setDaemon(true); // optional
       thread.start();

  ## 3. Stopping a Tailer

  Remember to stop the tailer when you have done with it:

       tailer.stop();

  ## 4. Interrupting a Tailer

  You can interrupt the thread a tailer is running on by calling `Thread.interrupt()`.

       thread.interrupt();

  If you interrupt a tailer, the tailer listener is called with the `InterruptedException`.

  The file is read using the default Charset; this can be overridden if necessary.

  See Also:
    `Tailer.Builder`, `TailerListener`, `TailerListenerAdapter`

- - ### Nested Class Summary

    Nested Classes
    Modifier and Type | Class and Description
    --- | ---
    `static class` | `Tailer.Builder` Builds a new `Tailer`.
    `static interface` | `Tailer.RandomAccessResourceBridge` Bridges access to a resource for random access, normally a file.
    `static interface` | `Tailer.Tailable` A tailable resource like a file.

  - ### Method Summary

    All Methods Static Methods Instance Methods Concrete Methods
    Modifier and Type | Method and Description
    --- | ---
    `static Tailer.Builder` | `builder()` Constructs a new `Tailer.Builder`.
    `void` | `close()` Requests the tailer to complete its current loop and return.
    `java.time.Duration` | `getDelayDuration()` Gets the delay Duration.
    `File` | `getFile()` Gets the file.
    `protected boolean` | `getRun()` Gets whether to keep on running.
    `Tailer.Tailable` | `getTailable()` Gets the Tailable.
    `void` | `run()` Follows changes in the file, calling `TailerListener.handle(String)` with each new line.

    - ### Methods inherited from class java.lang.Object

      `clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

- - ### Method Detail

    - #### builder

          public static Tailer.Builder builder()

      Constructs a new `Tailer.Builder`.
      Returns:
        Creates a new `Tailer.Builder`.

    - #### close

          public void close()

      Requests the tailer to complete its current loop and return.
      Specified by:
        `close` in interface `AutoCloseable`

    - #### getDelayDuration

          public java.time.Duration getDelayDuration()

      Gets the delay Duration.
      Returns:
        the delay Duration.

    - #### getFile

          public File getFile()

      Gets the file.
      Returns:
        the file
      Throws:
        `IllegalStateException` - if constructed using a user provided `Tailer.Tailable` implementation

    - #### getRun

          protected boolean getRun()

      Gets whether to keep on running.
      Returns:
        whether to keep on running.

    - #### getTailable

          public Tailer.Tailable getTailable()

      Gets the Tailable.
      Returns:
        the Tailable

    - #### run

          public void run()

      Follows changes in the file, calling `TailerListener.handle(String)` with each new line.
      Specified by:
        `run` in interface `Runnable`