*/
  private static final Collector<Object, ?, Optional<Object>> TO_OPTIONAL =
      Collector.of(
          ToOptionalState::new,
          ToOptionalState::add,
          ToOptionalState::combine,
          ToOptionalState::getOptional,
          Collector.Characteristics.UNORDERED);

  /**
   * A collector that converts a stream of zero or one elements to an {@code Optional}.
   *

        candidate = next;
      } else {
        return candidate;
      }
    }
  }

  /**
   * Returns a hash code, having the same bit length as each of the input hash codes, that combines
   * the information of these hash codes in an ordered fashion. That is, whenever two equal hash
   * codes are produced by two calls to this method, it is <i>as likely as possible</i> that each

        *   Implicit masks for `query`, `key` and `value` inputs will
            automatically be used to compute a correct attention mask for the
            layer. These padding masks will be combined with any
            `attention_mask` passed in directly when calling the layer. This can
            be used with
            [`tf.keras.layers.Embedding`](https://www.tensorflow.org/api_docs/python/tf/keras/layers/Embedding)

7. Aquí el `response_model` está usando una anotación de tipo de una lista de dataclasses `Author`.

    Nuevamente, puedes combinar `dataclasses` con anotaciones de tipos estándar.

8. Nota que esta *path operation function* usa `def` regular en lugar de `async def`.

    Como siempre, en FastAPI puedes combinar `def` y `async def` según sea necesario.

7. Aqui o `response_model` está usando uma anotação de tipo de uma lista de dataclasses `Author`.

    Novamente, você pode combinar `dataclasses` com anotações de tipo padrão.

8. Note que esta *função de operação de rota* usa `def` regular em vez de `async def`.

    Como sempre, no FastAPI você pode combinar `def` e `async def` conforme necessário.

        && this.funnel.equals(that.funnel);
  }

  /**
   * Combines this Bloom filter with another Bloom filter by performing a bitwise OR of the
   * underlying data. The mutations happen to <b>this</b> instance. Callers must ensure the Bloom
   * filters are appropriately sized to avoid saturating them.
   *
   * @param that The Bloom filter to combine this Bloom filter with. It is not mutated.

      }
    }

    @Override
    protected void processRemaining(ByteBuffer bb) {
      if (finished) {
        return;
      }
      crc0 = combine(0, crc0);
      crc0 = combine(crc0, crc1);
      crc0 = combine(crc0, crc2);
      crc0 = combine(crc0, crc3);
      while (bb.hasRemaining()) {
        crc0 = (crc0 >>> 8) ^ byteTable[(bb.get() ^ crc0) & 0xFF];
      }
      finished = true;
    }

 */
package jcifs;

import java.util.Iterator;

/**
 * An iterator that implements AutoCloseable to allow resource cleanup.
 * This interface combines Iterator functionality with automatic resource management.
 *
 * @param <T> the type of elements returned by this iterator
 * @author mbechler
 */
public interface CloseableIterator<T> extends Iterator<T>, AutoCloseable {

 */
package jcifs.internal.fscc;

import jcifs.internal.SmbBasicFileInfo;

/**
 * File System Control Code (FSCC) interface for Basic File Information.
 * Combines SMB basic file info with FSCC file information capabilities,
 * providing access to fundamental file metadata used in SMB file system operations.
 *
 * @author mbechler
 */

    * These `dependencies` are run before the normal parameter dependencies. And normal dependencies are run too. They can be combined.
    * Dependencies declared in a router are executed first, then the ones defined in *path operation decorators*, and then the ones declared in normal parameters. They are all combined and executed.