### Outras funções de utilidade { #other-utility-functions }

    /**
     * Get the value for the key 'indexer.thread.dump.enabled'. <br>
     * The value is, e.g. true <br>
     * comment: Whether to enable thread dump for the indexer.
     * @return The value of found property. (NotNull: if not found, exception but basically no way)
     */
    String getIndexerThreadDumpEnabled();

    /**
     * Is the property for the key 'indexer.thread.dump.enabled' true? <br>

            }
        } catch (final InterruptedException e) {
            logger.warn("[LLM] Request interrupted while waiting for concurrency permit. name={}", getName());
            Thread.currentThread().interrupt();
            throw new LlmException("Request interrupted", LlmException.ERROR_TIMEOUT);
        }
    }

    /**

   * undocumented and subject to change.
   *
   * <p>This method is safe to use even when {@code sortedMultiset} is a synchronized or concurrent
   * collection that is currently being modified by another thread.
   *
   * @throws NullPointerException if {@code sortedMultiset} or any of its elements is null
   */
  public static <E> ImmutableSortedMultiset<E> copyOfSorted(SortedMultiset<E> sortedMultiset) {

    /** The key of the message: Unauthorized request. */
    public static final String ERRORS_unauthorized_request = "{errors.unauthorized_request}";

    /** The key of the message: Failed to print a thread dump. */
    public static final String ERRORS_failed_to_print_thread_dump = "{errors.failed_to_print_thread_dump}";

    /** The key of the message: {0} is not supported. */

   * in the manner of {@link Number#intValue}.
   *
   * <p>Elements are copied from the argument collection as if by {@code collection.toArray()}.
   * Calling this method is as thread-safe as calling that method.
   *
   * @param collection a collection of {@code Number} instances
   * @return an array containing the same values as {@code collection}, in the same order, converted
   *     to primitives

        // Full lease for read/write/handle operations
        if (hasWriteAccess || hasDeleteAccess) {
            return Smb2LeaseState.SMB2_LEASE_FULL; // Read + Write + Handle
        }
        // Read + Handle for read operations
        else if (hasReadAccess) {
            return Smb2LeaseState.SMB2_LEASE_READ_HANDLE; // Read + Handle
        }

   * value in the manner of {@link Number#floatValue}.
   *
   * <p>Elements are copied from the argument collection as if by {@code collection.toArray()}.
   * Calling this method is as thread-safe as calling that method.
   *
   * @param collection a collection of {@code Number} instances
   * @return an array containing the same values as {@code collection}, in the same order, converted
   *     to primitives

   * value in the manner of {@link Number#doubleValue}.
   *
   * <p>Elements are copied from the argument collection as if by {@code collection.toArray()}.
   * Calling this method is as thread-safe as calling that method.
   *
   * @param collection a collection of {@code Number} instances
   * @return an array containing the same values as {@code collection}, in the same order, converted
   *     to primitives

 * Unlike many other double-ended priority queues, it stores elements in a single array, as compact
 * as the traditional heap data structure used in {@link PriorityQueue}.
 *
 * <p>This class is not thread-safe, and does not accept null elements.
 *
 * <p><i>Performance notes:</i>
 *
 * <ul>
 *   <li>If you only access one end of the queue, and do use a maximum size, this class will perform