|| c == ':' // added
                || c == '/' // added
                || c == '+' // added
                || c == '%' // added
                || c == '=' // added
                || c == '&' // added
                || c == '?' // added
                || c == '#' // added
                || c == '[' // added
                || c == ']' // added
                || c == '@' // added

     *
     * @param rule the rule to be added
     */
    void addRule(Rule rule);

    /**
     * Adds a rule to the specified index.
     *
     * @param index the position at which the rule should be added
     * @param rule the rule to be added
     */
    /**
     * Adds a rule to the specified index.
     *
     * @param index the position at which the rule should be added
     * @param rule the rule to be added

    int added = 0;
    boolean interrupted = false;
    try {
      while (added < numElements) {
        // we could rely solely on #poll, but #drainTo might be more efficient when there are
        // multiple elements already available (e.g. LinkedBlockingQueue#drainTo locks only once)
        added += q.drainTo(buffer, numElements - added);

You can declare `examples` for a Pydantic model that will be added to the generated JSON Schema.

//// tab | Pydantic v2

{* ../../docs_src/schema_extra_example/tutorial001_py310.py hl[13:24] *}

////

//// tab | Pydantic v1

{* ../../docs_src/schema_extra_example/tutorial001_pv1_py310.py hl[13:23] *}

////

   */
  public static <K, V> Builder<K, V> builder() {
    return new Builder<>();
  }

  /**
   * Returns a new builder, expecting the specified number of entries to be added.
   *
   * <p>If {@code expectedSize} is exactly the number of entries added to the builder before {@link
   * Builder#build} is called, the builder is likely to perform better than an unsized {@link
   * #builder()} would have.
   *

    int added = 0;
    boolean interrupted = false;
    try {
      while (added < numElements) {
        // we could rely solely on #poll, but #drainTo might be more efficient when there are
        // multiple elements already available (e.g. LinkedBlockingQueue#drainTo locks only once)
        added += q.drainTo(buffer, numElements - added);

  - [Changes by Kind](#changes-by-kind)
    - [Feature](#feature)
    - [Bug or Regression](#bug-or-regression)
  - [Dependencies](#dependencies)
    - [Added](#added)
    - [Changed](#changed)
    - [Removed](#removed)
- [v1.31.11](#v13111)
  - [Downloads for v1.31.11](#downloads-for-v13111)
    - [Source Code](#source-code-1)
    - [Client Binaries](#client-binaries-1)

    *   Added `TensorSpec` support for CompositeTensors.
    *   Added `tf.linalg.tridiagonal_solve` op.
    *   Added partial_pivoting input parameter to `tf.linalg.tridiagonal_solve`.
    *   Added gradient to `tf.linalg.tridiagonal_solve`.
    *   Added `tf.linalg.tridiagonal_mul op`.
    *   Added GPU implementation of `tf.linalg.tridiagonal_matmul`.
    *   Added `LinearOperatorToeplitz`.

        assertNotNull(dcerpcBinding.getUuid(), "UUID should be set for newly added interface.");
        assertEquals("11111111-2222-3333-4444-555555555555", dcerpcBinding.getUuid().toString(),
                "UUID should be parsed correctly for newly added interface.");

        }
        int current = 0;
        boolean added = false;
        final Map<Pattern, CrawlerClient> newClientMap = new LinkedHashMap<>();
        for (final Map.Entry<Pattern, CrawlerClient> entry : clientMap.entrySet()) {
            if (pos == current) {
                newClientMap.put(Pattern.compile(regex), client);
                added = true;
            }