}
        }

        return new ExtractData(buf.toString().trim());
    }

    /**
     * Sets the maximum content size.
     * @param maxContentSize The maximum content size to set.
     */
    public void setMaxContentSize(final long maxContentSize) {
        this.maxContentSize = maxContentSize;
    }

    SmbFileHandle ensureOpen() throws CIFSException;

    /**
     * Receive data from the pipe
     *
     * @param buf buffer to receive data into
     * @param off offset in the buffer
     * @param length maximum length to receive
     * @return number of bytes received
     * @throws IOException if an I/O error occurs
     */
    int recv(byte[] buf, int off, int length) throws IOException;

    /**

            }
        }

        return buf.toString().trim();
    }

    /**
     * Sets the maximum content size.
     * @param maxContentSize The maximum content size to set.
     */
    public void setMaxContentSize(final long maxContentSize) {
        this.maxContentSize = maxContentSize;
    }

    }

    /**
     * Sets the maximum number of session IDs to include in session ID lists.
     * This controls the size limit for aggregation results when retrieving session lists.
     *
     * @param maxSessionIdsInList the maximum number of session IDs to include in lists
     */
    public void setMaxSessionIdsInList(final int maxSessionIdsInList) {

    }

    /**
     * Gets the maximum allowed length for site strings from configuration.
     *
     * @return the maximum site length as configured
     */
    default int getMaxSiteLength() {
        return getFessConfig().getCrawlerDocumentMaxSiteLengthAsInteger();
    }

    /**
     * Abbreviates a site string to the maximum allowed length if configured.
     *

        // Utility class - not instantiable
    }

    private static final int MAX_BUFFERS = Config.getInt("jcifs.smb1.smb.maxBuffers", 16);
    private static final int MAX_BUFFER_SIZE = 0x100000; // 1MB maximum

    // Use concurrent queue for lock-free operations
    private static final java.util.concurrent.ConcurrentLinkedQueue<byte[]> bufferQueue =
            new java.util.concurrent.ConcurrentLinkedQueue<>();

import java.io.IOException;
import java.util.List;

/**
 * Interface for converting text into its reading form.
 */
public interface ReadingConverter {

    /**
     * Returns the maximum number of readings.
     *
     * @return the maximum number of readings, default is 10.
     */
    default int getMaxReadingNum() {
        return 10;
    }

    /**
     * Initializes the converter.
     *

    /**
     * Finds the null termination in a UTF-16LE encoded string buffer.
     *
     * @param buffer the byte buffer to search
     * @param bufferIndex the starting position in the buffer
     * @param maxLen the maximum length to search
     * @return position of terminating null bytes
     */
    public static int findUNITermination(final byte[] buffer, final int bufferIndex, final int maxLen) {
        int len = 0;

    private static final int MAX_BACKOFF_SHIFT = 4; // Maximum 16x multiplier

    private final RdmaStatistics statistics;
    private final int maxRetries;
    private final long retryDelayMs;

    /**
     * Create new RDMA error handler
     *
     * @param statistics statistics tracker
     * @param maxRetries maximum number of retries for recoverable errors

import java.util.Map.Entry;
import org.jspecify.annotations.Nullable;

/**
 * Simple helper class to build a "sparse" array of objects based on the indexes that were added to
 * it. The array will be from 0 to the maximum index given. All non-set indexes will contain null
 * (so it's not really a sparse array, just a pseudo sparse array). The builder can also return a
 * CharEscaper based on the generated array.
 *
 * @author Sven Mawson