private static final long serialVersionUID = 1L;

    /**
     * Default initial capacity.
     */
    protected static final int DEFAULT_INITIAL_CAPACITY = 16;

    /**
     * Default load factor.
     */
    protected static final float DEFAULT_LOAD_FACTOR = 0.75f;

    /**
     * Upper limit on the number of entries.
     */
    protected final int limitSize;

    /**

    }

    /**
     * Converts a phrase query to a query builder.
     *
     * @param context the query context
     * @param phraseQuery the phrase query
     * @param boost the boost factor
     * @return the query builder
     */
    protected QueryBuilder convertPhraseQuery(final QueryContext context, final PhraseQuery phraseQuery, final float boost) {
        final Term[] terms = phraseQuery.getTerms();

     *
     * @param context the query context containing search configuration
     * @param query the Lucene query to convert (must be a FuzzyQuery)
     * @param boost the boost factor to apply to the query
     * @return OpenSearch QueryBuilder for fuzzy matching
     * @throws InvalidQueryException if the query is not a FuzzyQuery
     */
    @Override

import org.lastaflute.core.message.UserMessages;
import org.opensearch.index.query.QueryBuilder;

/**
 * Query command implementation for handling Boost queries.
 * Processes Lucene BoostQuery objects and applies boost factors.
 */
public class BoostQueryCommand extends QueryCommand {
    /**
     * Default constructor for BoostQueryCommand.
     */
    public BoostQueryCommand() {
        super();
    }

    // Round down to the nearest power of 2.
    expectedEntries = max(expectedEntries, 2);
    int tableSize = Integer.highestOneBit(expectedEntries);
    // Check to make sure that we will not exceed the maximum load factor.
    if (expectedEntries > (int) (loadFactor * tableSize)) {
      tableSize <<= 1;
      return (tableSize > 0) ? tableSize : MAX_TABLE_SIZE;
    }
    return tableSize;
  }

     * Executes query processing through the filter chain.
     *
     * @param context the query context containing search parameters and state
     * @param query the Lucene query to be processed
     * @param boost the boost factor to apply to the query
     * @return the processed OpenSearch QueryBuilder
     */
    public QueryBuilder execute(final QueryContext context, final Query query, final float boost) {

    }

    /**
     * Converts a Lucene BooleanQuery to an OpenSearch BoolQueryBuilder.
     * @param context The query context.
     * @param booleanQuery The boolean query to convert.
     * @param boost The boost factor to apply.
     * @return The converted BoolQueryBuilder.
     */
    protected QueryBuilder convertBooleanQuery(final QueryContext context, final BooleanQuery booleanQuery, final float boost) {

   * next entry in the bucket chain). The pointers in [size(), entries.length) are all "null"
   * (UNSET).
   */
  @VisibleForTesting transient long[] entries;

  /** The load factor. */
  private transient float loadFactor;

  /** When we have this many elements, resize the hashtable. */
  private transient int threshold;

  /** Constructs a new empty instance of {@code ObjectCountHashMap}. */

            for (i in 2..997) {
              sink.writeUtf8(String.format(" * $i = ${factor(i)}\n"))
            }
          }

          private fun factor(n: Int): String {
            for (i in 2 until n) {
              val x = n / i
              if (x * i == n) return "${factor(x)} × $i"
            }
            return n.toString()
          }
        }

     *
     * @param <K> the key type of {@link ConcurrentHashMap}
     * @param <V> the value type of {@link ConcurrentHashMap}
     * @param initialCapacity the initial capacity
     * @param loadFactor the load factor threshold for resizing
     * @param concurrencyLevel the estimated number of threads for concurrent updates
     * @return a new instance of {@link ConcurrentHashMap}