*
     * @param context the query context
     * @param termQuery the term query to convert
     * @param boost the boost value to apply
     * @return the converted QueryBuilder
     */
    protected QueryBuilder convertTermQuery(final QueryContext context, final TermQuery termQuery, final float boost) {
        final String field = getSearchField(context.getDefaultField(), termQuery.getTerm().field());

            throw new CIFSException("Preauth integrity context is invalid for session: " + sessionId);
        }

        try {
            byte[] newHash = calculateHash(context.getCurrentHash(), messageData, context.getHashAlgorithm());
            context.updateHash(newHash);

            log.debug("Updated preauth hash for session {} with {} bytes of data", sessionId, messageData.length);

    CIFSContext withDefaultCredentials();

    /**
     * Create a child context with anonymous credentials
     *
     * @return a child context using anonymous credentials
     */
    CIFSContext withAnonymousCredentials();

    /**
     * Create a child context with guest credentials
     *
     * @return a child context using guest credentials
     */
    CIFSContext withGuestCrendentials();

    /**

     *
     * @param serverAddress the witness server address
     * @param context the CIFS context
     * @throws IOException if connection fails
     */
    public WitnessRpcClient(InetAddress serverAddress, CIFSContext context) throws IOException {
        this.serverAddress = serverAddress;
        this.context = context;

        try {
            // Create DCE/RPC handle for witness service

        return category;
    }

    /**
     * Gets the error context
     *
     * @return the context map
     */
    public Map<String, Object> getContext() {
        return new HashMap<>(context);
    }

    /**
     * Gets a specific context value
     *
     * @param key the context key
     * @return the context value or null
     */
    public Object getContextValue(String key) {

        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,
                    (f, b) -> QueryBuilders.fuzzyQuery(f, text)

            contextPath = contextPath.replaceAll("/+$", StringUtil.EMPTY);
        }
        final Context context = (Context) server.getHost().findChild(contextPath);
        if (context != null) {
            context.setResources(new FessWebResourceRoot(context));
            context.setCookieProcessor(new Rfc6265CookieProcessor());
        }
    }

    /**

        return this.fileName;
    }

    /**
     * Get the create context responses
     * @return the createContexts
     */
    public CreateContextResponse[] getCreateContexts() {
        return this.createContexts;
    }

    /**
     * Get the lease V1 context response if present
     * @return the lease V1 context or null if not present
     */

        }

        if (isSearchField(field)) {
            context.addFieldLog(field, text);
            stream(texts).of(stream -> stream.forEach(t -> context.addHighlightedQuery(t)));
            return buildMatchPhraseQuery(field, text);
        }

        context.addFieldLog(Constants.DEFAULT_FIELD, text);

            // Reuse context map or create new
            entry.context = getContextMap();
            if (context != null) {
                entry.context.putAll(maskContext(context));
            }

            // Add MDC context efficiently
            addMdcContext(entry.context);

            // Process asynchronously or synchronously based on configuration