* decide not to by returning -1L.
 *
 * Task Queues
 * -----------
 *
 * Tasks are bound to the [TaskQueue] they are scheduled in. Each queue is sequential and the tasks
 * within it never execute concurrently. It is an error to use a task in multiple queues.
 */
abstract class Task(
  val name: String,
  val cancelable: Boolean = true,
) {
  // Guarded by the TaskRunner.
  internal var queue: TaskQueue? = null

Directory for DBFlute client

manage.bat(sh) => 21 (jdbc):
A execution command of JDBC task
which gets your schema info and saves it to SchemaXML
located to the "schema" directory.
This task should be executed after ReplaceSchema task
and before other tasks(e.g. Generate, Document task).

manage.bat(sh) => 22 (doc):
A execution command of Document task
which creates documents, for example, SchemaHTML, HistoryHTML
to the "output/doc" directory.

  }

  /**
   * Wraps a collection of tasks.
   *
   * @throws NullPointerException if any element of {@code tasks} is null
   */
  private <T extends @Nullable Object> ImmutableList<Callable<T>> wrapTasks(
      Collection<? extends Callable<T>> tasks) {
    ImmutableList.Builder<Callable<T>> builder = ImmutableList.builder();
    for (Callable<T> task : tasks) {
      builder.add(wrapTask(task));
    }
    return builder.build();
  }

{* ../../docs_src/background_tasks/tutorial001.py hl[6:9] *}

## Add the background task { #add-the-background-task }

Inside of your *path operation function*, pass your task function to the *background tasks* object with the method `.add_task()`:

{* ../../docs_src/background_tasks/tutorial001.py hl[14] *}

`.add_task()` receives as arguments:

* A task function to be run in the background (`write_notification`).

   * started. Similarly the task will be delayed if the host lacks compute resources.
   *
   * @throws RejectedExecutionException if the queue is shut down and the task is not cancelable.
   */
  fun schedule(
    task: Task,
    delayNanos: Long = 0L,
  ) {
    taskRunner.withLock {
      if (shutdown) {
        if (task.cancelable) {

							task.event.StorageClass, task.objInfo.Bucket, task.objInfo.Name, task.objInfo.VersionID, err))
					}
				}
			} else {
				ts := tierStats{
					TotalSize:   uint64(task.objInfo.Size),
					NumVersions: 1,
				}
				if task.objInfo.IsLatest {
					ts.NumObjects = 1
				}
				t.addLastDayStats(task.event.StorageClass, ts)
			}
			t.activeTasks.Add(-1)

import java.util.logging.Level
import java.util.logging.Logger

internal inline fun Logger.taskLog(
  task: Task,
  queue: TaskQueue,
  messageBlock: () -> String,
) {
  if (isLoggable(Level.FINE)) {
    log(task, queue, messageBlock())
  }
}

internal inline fun <T> Logger.logElapsed(
  task: Task,
  queue: TaskQueue,
  block: () -> T,
): T {
  var startNs = -1L

  /**
   * True if this task faker has ever had multiple tasks scheduled to run concurrently. Guarded by
   * `this`.
   */
  var isParallel = false

  /** Number of calls to [TaskRunner.Backend.execute]. Guarded by `this`. */
  var executeCallCount = 0

  /** Guarded by [taskRunner]. */
  var nanoTime = 0L
    private set

  /** Backlog of tasks to run. Only one task runs at a time. Guarded by `this`. */

  public <T> ListenableFuture<T> submit(Callable<T> task) {
    Preconditions.checkNotNull(task, "task must not be null!");
    return delegate.submit(task);
  }

  @Override
  public <T> ListenableFuture<T> submit(Runnable task, T result) {
    Preconditions.checkNotNull(task, "task must not be null!");
    Preconditions.checkNotNull(result, "result must not be null!");
    return delegate.submit(task, result);
  }

  @Override

  public <T> ListenableFuture<T> submit(Callable<T> task) {
    Preconditions.checkNotNull(task, "task must not be null!");
    return delegate.submit(task);
  }

  @Override
  public <T> ListenableFuture<T> submit(Runnable task, T result) {
    Preconditions.checkNotNull(task, "task must not be null!");
    Preconditions.checkNotNull(result, "result must not be null!");
    return delegate.submit(task, result);
  }

  @Override