* form parameter names and values</a>. Escaping is performed with the UTF-8 character encoding.
   * The caller is responsible for <a
   * href="https://html.spec.whatwg.org/multipage/form-control-infrastructure.html#multipart-form-data">replacing
   * any unpaired carriage return or line feed characters with a CR+LF pair</a> on any non-file
   * inputs before escaping them with this escaper.
   *

    protected GeoInfo defaultGeoInfo;

    /** Map containing field-specific boost values for search scoring */
    protected Map<String, String> fieldBoostMap = new HashMap<>();

    /** List of boost functions to be applied to search queries for custom scoring */
    protected List<FilterFunctionBuilder> boostFunctionList = new ArrayList<>();

    assertLessThan(NEW, TERMINATED);

    assertLessThan(STARTING, RUNNING);
    assertLessThan(STARTING, STOPPING);
    assertLessThan(STARTING, FAILED);

    assertLessThan(RUNNING, STOPPING);
    assertLessThan(RUNNING, FAILED);

    assertLessThan(STOPPING, FAILED);
    assertLessThan(STOPPING, TERMINATED);
  }

  private static <T extends Comparable<? super T>> void assertLessThan(T a, T b) {

 * general way.
 *
 * <p>A good example of usage of this class is for HTML escaping where the replacement array
 * contains information about the named HTML entities such as {@code &amp;} and {@code &quot;} while
 * {@link #escapeUnsafe} is overridden to handle general escaping of the form {@code &#NNNNN;}.
 *
 * <p>The size of the data structure used by {@link ArrayBasedUnicodeEscaper} is proportional to the

    protected int maxErrorCount = 2;

    /** List of finished crawler session IDs for cleanup */
    protected List<String> finishedSessionIdList = new ArrayList<>();

    /** List of document boost matchers for scoring enhancement */
    private final List<DocBoostMatcher> docBoostMatcherList = new ArrayList<>();

    /** List of active crawler instances */
    private List<Crawler> crawlerList;

    return new ListenerCallQueue.Event<Listener>() {
      @Override
      public void call(Listener listener) {
        listener.stopping(from);
      }

      @Override
      public String toString() {
        return "stopping({from = " + from + "})";
      }
    };
  }

  private final Monitor monitor = new Monitor();

        return value;
    }

    /**
     * Escapes special characters in a query string if escaping is enabled.
     * Replaces reserved characters with their escaped equivalents based on the Constants.RESERVED array.
     *
     * @param value the query string to escape
     * @return the escaped query string, or the original value if escaping is disabled
     */
    protected String escapeQuery(final String value) {
        if (!escape) {

     */
    public SearchForm() {
    }

    /**
     * The URL expression field for boost document configuration.
     */
    public String urlExpr;

    /**
     * The boost expression field for document scoring.
     */
    public String boostExpr;

    if (uriStripped) {
      if (uri.toString() != component.urlString("")) {
        fail("Encoding $component $codePoint using $encoding")
      }
      return
    }

    // If the URI has more escaping than the HttpURL, check that the decoded values still match.
    val uriEscaped = uriEscapedCodePoints.indexOf(codePointString) != -1
    if (uriEscaped) {
      if (uri.toString() == httpUrl.toString()) {

    assertEscaping(xmlEscaper, "\uFFFD", '\uFFFF');

    assertEquals(
        "0xFFFE is forbidden and should be replaced during escaping",
        "[\uFFFD]",
        xmlEscaper.escape("[\ufffe]"));
    assertEquals(
        "0xFFFF is forbidden and should be replaced during escaping",
        "[\uFFFD]",
        xmlEscaper.escape("[\uffff]"));
  }