this.daemon = daemon;
    }

    /**
     * Runs the crawling process in a separate thread.
     * This method initializes the crawler context, creates and starts crawler threads,
     * and waits for their completion.
     */
    @Override
    public void run() {
        if (logger.isInfoEnabled()) {

1. Definitions
--------------

1.1. "Contributor"
    means each individual or legal entity that creates, contributes to
    the creation of, or owns Covered Software.

1.2. "Contributor Version"
    means the combination of the Contributions of others (if any) used
    by a Contributor and that particular Contributor's Contribution.

1.3. "Contribution"
    means Covered Software of a particular Contributor.

1.4. "Covered Software"

        try {
            deferred.promise().getResponse(10, TimeUnit.SECONDS);
            fail();
        } catch (SuggesterException e) {
            assertEquals("An error occurred during the deferred computation.", e.getMessage());
        }
    }

   * required, to have the following properties:
   *
   * <ul>
   *   <li>Its execution does not cause any observable side effects.
   *   <li>The computation is <i>consistent with equals</i>; that is, {@link Objects#equal
   *       Objects.equal}{@code (a, b)} implies that {@code predicate.apply(a) ==
   *       predicate.apply(b))}.
   * </ul>
   *

     * @param notifyFlags
     *            the notifyFlags to set
     */
    public void setNotifyFlags(final int notifyFlags) {
        this.notifyFlags = notifyFlags;
    }

    /**
     * Set the completion filter specifying which changes to monitor
     *
     * @param completionFilter
     *            the completionFilter to set
     */
    public void setCompletionFilter(final int completionFilter) {

![editor support](https://fastapi.tiangolo.com/img/vscode-completion.png)

* no <a href="https://www.jetbrains.com/pycharm/" class="external-link" target="_blank">PyCharm</a>:

![editor support](https://fastapi.tiangolo.com/img/pycharm-completion.png)

So, the function below it will be executed once for each combination of arguments. And then the values returned by each of those combinations of arguments will be used again and again whenever the function is called with exactly the same combination of arguments.

For example, if you have a function:

```Python
@lru_cache
def say_hi(name: str, salutation: str = "Ms."):

 *
 * @author Kevin Bourrillion
 * @since 11.0
 */
@Immutable
public interface HashFunction {
  /**
   * Begins a new hash code computation by returning an initialized, stateful {@code Hasher}
   * instance that is ready to receive data. Example:
   *
   * {@snippet :
   * HashFunction hf = Hashing.md5();
   * HashCode hc = hf.newHasher()

 *
 * @author Kevin Bourrillion
 * @since 11.0
 */
@Immutable
public interface HashFunction {
  /**
   * Begins a new hash code computation by returning an initialized, stateful {@code Hasher}
   * instance that is ready to receive data. Example:
   *
   * {@snippet :
   * HashFunction hf = Hashing.md5();
   * HashCode hc = hf.newHasher()

            // Since the value of oldFuture can only ever be immediateVoidFuture() or setFuture of a
            // future that eventually came from immediateVoidFuture(), this doesn't leak throwables
            // or completion values.
            newFuture.setFuture(oldFuture);
          } else if (outputFuture.isCancelled() && taskExecutor.trySetCancelled()) {