stream(baseExcludes).of(stream -> stream.forEach(exclude -> popularWordsRequestBuilder.addExcludeWord(exclude)));
                try {
                    popularWordsRequestBuilder.execute().getResponse().getItems().stream().forEach(item -> wordList.add(item.getText()));
                } catch (final SuggesterException e) {
                    logger.warn("Failed to generate popular words.", e);
                }

     */
    @Override
    public ServerMessageBlock2Response getResponse () {
        return null;
    }


    /**
     * 
     * {@inheritDoc}
     *
     * @see jcifs.internal.CommonServerMessageBlock#setResponse(jcifs.internal.CommonServerMessageBlockResponse)
     */
    @Override
    public void setResponse ( CommonServerMessageBlockResponse msg ) {

    }


    /**

                builder.addKind(SuggestItem.Kind.DOCUMENT.toString());
            }

            final SuggestResponse suggestResponse = builder.execute().getResponse();

            buf.append("\"query_time\":").append(suggestResponse.getTookMs());
            buf.append(",\"record_count\":").append(suggestResponse.getTotal());

                this.response_map.remove(curResp.getMid());
                Request next = curReq.getNext();
                if ( next != null ) {
                    curReq = next;
                    curResp = next.getResponse();
                }
                else {
                    break;
                }
            }
        }
    }


    /**
     * @param request
     * @param response

import org.opensearch.action.bulk.BulkRequestBuilder;
import org.opensearch.action.bulk.BulkResponse;
import org.opensearch.action.delete.DeleteResponse;
import org.opensearch.action.get.GetResponse;
import org.opensearch.action.index.IndexResponse;
import org.opensearch.action.search.SearchRequestBuilder;
import org.opensearch.action.search.SearchResponse;
import org.opensearch.action.support.WriteRequest.RefreshPolicy;

        if (StringUtil.isNotBlank(cookiePath)) {
            cookie.setPath(cookiePath);
        }
        if (cookieSecure != null) {
            cookie.setSecure(cookieSecure);
        }
        LaResponseUtil.getResponse().addCookie(cookie);
    }

    protected String getUserCodeFromCookie(final HttpServletRequest request) {
        final FessConfig fessConfig = ComponentUtil.getFessConfig();

                }
            } catch (final ExecutionException e) {
                logger.debug("Failed to access {}", input, e);
            }
        }
        return LaResponseUtil.getResponse().encodeURL(sb.toString());
    }

    public static String sdh(final String input) {
        if (StringUtil.isBlank(input)) {
            return input;
        }

        resolver.resolve(OpenIdConnectCredential.class, credential -> OptionalEntity.of(credential.getUser()));
    }

    @Override
    public ActionResponse getResponse(final SsoResponseType responseType) {
        return null;
    }

    @Override
    public String logout(final FessUserBean user) {
        return null;
    }

            final SearchResult<T, GetRequestBuilder, GetResponse> searchResult) {
        final SystemHelper systemHelper = ComponentUtil.getSystemHelper();
        final long startTime = systemHelper.getCurrentTimeAsLong();

        GetResponse response = null;
        final GetRequestBuilder requestBuilder = client.prepareGet(index, id);

        dstIndex += writeAndXWireFormat(dst, dstIndex);
        this.length = dstIndex - start;

        if ( this.digest != null ) {
            this.digest.sign(dst, this.headerStart, this.length, this, this.getResponse());
        }

        return this.length;
    }


    /*
     * We overload this because we want readAndXWireFormat to
     * read the parameter words and bytes. This is so when