}

    private void validatePasswordForm(final PasswordForm form, final VaErrorHook validationErrorLambda) {
        validate(form, messages -> {}, validationErrorLambda);

        if (!form.password.equals(form.confirmPassword)) {
            throwValidationError(messages -> {
                messages.addErrorsInvalidConfirmPassword(GLOBAL);
            }, validationErrorLambda);
        }

        final Term term = fuzzyQuery.getTerm();
        final String field = getSearchField(context.getDefaultField(), term.field());

        if (Constants.DEFAULT_FIELD.equals(field)) {
            final String text = term.text();
            context.addFieldLog(field, text);
            context.addHighlightedQuery(text);
            return buildDefaultQueryBuilder(fessConfig, context,

            if (name.startsWith(concurrentPackage)
                // Use other classloader for ListenableFuture, so that the objects can interact
                && !ListenableFuture.class.getName().equals(name)) {
              synchronized (loadedClasses) {
                Class<?> toReturn = loadedClasses.get(name);
                if (toReturn == null) {
                  toReturn = super.findClass(name);

    public void clear() {
      throw new UnsupportedOperationException();
    }

    @Override
    public int count(@Nullable Object element) {
      for (Entry<E> entry : entrySet()) {
        if (Objects.equals(entry.getElement(), element)) {
          return entry.getCount();
        }
      }
      return 0;
    }

    @Override
    public int add(E element, int occurrences) {

              .transform(TypeToken::getRawType)
              .transformAndConcat(c -> asList(c.getDeclaredMethods()))
              .firstMatch(
                  m ->
                      m.getName().equals("writeReplace")
                          && m.getParameterTypes().length == 0
                          // Only package-private methods are a problem.

            if (name.startsWith(concurrentPackage)
                // Use other classloader for ListenableFuture, so that the objects can interact
                && !ListenableFuture.class.getName().equals(name)) {
              synchronized (loadedClasses) {
                Class<?> toReturn = loadedClasses.get(name);
                if (toReturn == null) {
                  toReturn = super.findClass(name);

        bitSum += function.bits();
      }
      return bitSum;
    }

    @Override
    public boolean equals(@Nullable Object object) {
      if (object instanceof ConcatenatedHashFunction) {
        ConcatenatedHashFunction other = (ConcatenatedHashFunction) object;
        return Arrays.equals(functions, other.functions);
      }
      return false;
    }

    @Override
    public int hashCode() {

      int bucketLength = 0;
      do {
        entryIndex = next - 1;
        entry = entries[entryIndex];
        if (CompactHashing.getHashPrefix(entry, mask) == hashPrefix
            && Objects.equals(object, elements[entryIndex])) {
          return false;
        }
        next = CompactHashing.getNext(entry, mask);
        bucketLength++;
      } while (next != UNSET);

     * @param path     the request path after removing the prefix
     */
    protected void processRequest(final HttpServletRequest request, final HttpServletResponse response, final String path) {
        if ("/_plugin".equals(path) || path.startsWith("/_plugin/")) {
            processPluginRequest(request, response, path.replaceFirst("^/_plugin", StringUtil.EMPTY));
            return;
        }

        String userCode = sessionManager.getAttribute(USER_BEAN, TypicalUserBean.class)
                .filter(u -> !Constants.EMPTY_USER_ID.equals(u.getUserId()))
                .map(u -> u.getUserId().toString())
                .orElse(StringUtil.EMPTY);
        if (StringUtil.isBlank(userCode)) {
            return null;
        }