* is {@link #MODULES}, then this method returns {@code "--module-path"}. The option
     * does not include the {@linkplain Modular#moduleName() module name} on which it applies.
     *
     * @return the name of the tool option for this path type
     */
    @Nonnull
    @Override
    public Optional<String> option() {
        return Optional.ofNullable(option);
    }

            try (Stream<T> s = supplier.get()) {
                stream.accept(s);
            }
        }

        /**
         * Applies the given function to a stream created by the supplier and returns the result.
         * The stream is automatically closed after the function is applied.
         *
         * @param <R> The type of the result returned by the function.

     * during model building, based on the POM schema version.
     * <p>
     * The validation levels are cumulative, with higher versions including all validations
     * from lower versions plus additional checks specific to that version.
     */
    enum Version {
        /**
         * Base validation level that applies to all POM versions.

       * cancelled.
       */
      @ParametricNullness
      U apply(DeferredCloser closer, @ParametricNullness V1 value1, @ParametricNullness V2 value2)
          throws Exception;
    }

    /**
     * A function that returns a {@link ClosingFuture} when applied to the values of the two futures
     * passed to {@link #whenAllSucceed(ClosingFuture, ClosingFuture)}.
     *

```Python
q: str | None = None
```

But the `Query` version declares it explicitly as being a query parameter.

Then, we can pass more parameters to `Query`. In this case, the `max_length` parameter that applies to strings:

```Python
q: str | None = Query(default=None, max_length=50)
```

        pw.println("                                 cantaloupe, watermelon, \\");
        pw.println("                                 kiwi, mango");

        java.util.Properties p = new java.util.Properties();
        p.load(new StringReader(sw.toString()));
        Object o24 = p.getProperty("fruits");

But when you declare them with Python types (in the example above, as `int`), they are converted to that type and validated against it.

All the same process that applied for path parameters also applies for query parameters:

* Editor support (obviously)
* Data <abbr title="converting the string that comes from an HTTP request into Python data">"parsing"</abbr>
* Data validation
* Automatic documentation

   * | `http://host/?`                   | `""`                   |
   * | `http://host/?a=apple&k=key+lime` | `"a=apple&k=key+lime"` |
   * | `http://host/?a=apple&a=apricot`  | `"a=apple&a=apricot"`  |
   * | `http://host/?a=apple&b`          | `"a=apple&b"`          |
   */
  @get:JvmName("encodedQuery")
  val encodedQuery: String?
    get() {

            }
        } catch (final Exception e) {
            logger.warn("Failed to initialize TikaExtractor.", e);
        }
    }

    /**
     * Processes and normalizes a document title.
     * Applies text normalization using configured space characters and returns
     * a clean title suitable for indexing.
     *
     * @param responseData the response data from crawling (not currently used)

     * @param documentBoost the boost value to apply to the document
     */
    protected void addBoostValue(final Map<String, Object> map, final float documentBoost) {
        final FessConfig fessConfig = ComponentUtil.getFessConfig();
        map.put(fessConfig.getIndexFieldBoost(), documentBoost);
        if (logger.isDebugEnabled()) {