quitFlag = true
			}
		}
	}
	close(writer.doneCh)

	recordStagingTicker.Stop()
	keepAliveTicker.Stop()
	if progressTicker != nil {
		progressTicker.Stop()
	}

	// Whatever drain the payloadCh to prevent from memory leaking.
	for len(writer.payloadCh) > 0 {
		payload := <-writer.payloadCh
		bufPool.Put(payload)
	}
}

// Sends a single whole record.

    return builder.toString();
  }

  /**
   * Returns an immutable array containing the same values as {@code this} array. This is logically
   * a no-op, and in some circumstances {@code this} itself is returned. However, if this instance
   * is a {@link #subArray} view of a larger array, this method will copy only the appropriate range
   * of values, resulting in an equivalent array with a smaller memory footprint.
   */

         * Therefore, we can always create our own TypeVariable. (One downside of our TypeVariable
         * in some situations is that it does not support the AnnotatedType API. However, those
         * situations don't arise under Android because Android does not provide the AnnotatedType
         * API at all.)
         *

 *
 * <p>This class supports an optional fairness policy for ordering waiting producer and consumer
 * threads. By default, this ordering is not guaranteed. However, a queue constructed with fairness
 * set to {@code true} grants threads access in FIFO order. Fairness generally decreases throughput
 * but reduces variability and avoids starvation.
 *

    return builder.toString();
  }

  /**
   * Returns an immutable array containing the same values as {@code this} array. This is logically
   * a no-op, and in some circumstances {@code this} itself is returned. However, if this instance
   * is a {@link #subArray} view of a larger array, this method will copy only the appropriate range
   * of values, resulting in an equivalent array with a smaller memory footprint.
   */

All the same options are supported.

All the same `parameters`, `responses`, `dependencies`, `tags`, etc.

/// tip

In this example, the variable is called `router`, but you can name it however you want.

///

We are going to include this `APIRouter` in the main `FastAPI` app, but first, let's check the dependencies and another `APIRouter`.

## Dependencies { #dependencies }

         * AbstractIteratorTester<E>.MultiExceptionListIterator. The runtime won't be able to verify
         * the AbstractIteratorTester<E> part, so it's an unchecked cast. We know, however, that the
         * only possible value for the type parameter is <E>, since otherwise the
         * MultiExceptionListIterator wouldn't be an Iterator<E>. The cast is safe, even though
         * javac can't tell.

        BloomFilter.readFrom(new ByteArrayInputStream(out.toByteArray()), funnel);
    assertThat(read).isEqualTo(bf);
    assertThat(read.expectedFpp()).isGreaterThan(0);
  }

  /**
   * This test will fail whenever someone updates/reorders the BloomFilterStrategies constants. Only
   * appending a new constant is allowed.
   */
  // This test ensures that our reliance on the ordering elsewhere is safe.

         * AbstractIteratorTester<E>.MultiExceptionListIterator. The runtime won't be able to verify
         * the AbstractIteratorTester<E> part, so it's an unchecked cast. We know, however, that the
         * only possible value for the type parameter is <E>, since otherwise the
         * MultiExceptionListIterator wouldn't be an Iterator<E>. The cast is safe, even though
         * javac can't tell.

  }

  public static class WithExceptionalConstructor {
    public static final WithExceptionalConstructor INSTANCE =
        new WithExceptionalConstructor("whatever");

    public WithExceptionalConstructor() {
      throw new RuntimeException();
    }

    private WithExceptionalConstructor(String unused) {}
  }

  private static class WithPublicConstant {