return inputStream.read(b, off, len);
    }

    /**
     * Reads some number of bytes from the input stream and stores them into the buffer array b.
     *
     * @param b the buffer into which the data is read
     * @return the total number of bytes read into the buffer, or -1 if there is no more data
     * @throws IOException if an I/O error occurs
     */
    @Override
    public int read(final byte[] b) throws IOException {

/**
 * The {@code QueryLogReader} interface provides methods to read query logs and close the reader.
 * It extends the {@code Closeable} interface, ensuring that resources can be released when no longer needed.
 */
public interface QueryLogReader extends Closeable {
    /**
     * Reads a query log.
     * @return The query log.
     */
    QueryLog read();

    @Override
    void close();

 */
public interface DocumentReader extends Closeable {
    /**
     * Reads a document and returns its contents as a map.
     *
     * @return a map containing the document's data, or null if there are no more documents to read.
     */
    Map<String, Object> read();

    @Override
    void close();

     * This method delegates to {@link FileInputStream#mark(int)}.
     *
     * @param readlimit the maximum limit of bytes that can be read before the mark position becomes invalid
     */
    @Override
    public synchronized void mark(final int readlimit) {

/**
 * <p>
 * {@link ESSourceReader} reads documents from Elasticsearch using the scroll API.
 * It implements the {@link DocumentReader} interface to provide a way to iterate over documents
 * in a large index without loading all of them into memory at once.
 * </p>
 *
 * <p>
 * The reader supports limiting the number of documents read based on a percentage of the total documents

 * as a ByteArrayInputStream.
 * </p>
 *
 * <p>
 * The transform method takes a ResponseData object, checks if it has a response body,
 * and then reads the body into a byte array. This byte array is then set as the data
 * in the ResultData object.
 * </p>
 *
 * <p>
 * The getData method takes an AccessResultData object, checks if the transformer name matches,

            this.reader = reader;
        }

        /**
         * Executes the text processing operation on the provided reader.
         *
         * This method reads characters from the reader and processes them according to the following rules:
         * - ISO control characters and space characters are treated as spaces.

        // Test user boost
        item.setUserBoost(2.0f);
        assertEquals(2.0f, item.getUserBoost(), 0.001f);

        // Test readings
        String[][] newReadings = { { "read1", "read2" }, { "read3" } };
        item.setReadings(newReadings);
        assertArrayEquals(newReadings, item.getReadings());

        // Test fields
        String[] fields = { "field1", "field2" };

        reader.setScrollSize(1000);
        int count = 0;
        Set<String> valueSet = Collections.synchronizedSet(new HashSet<>());
        Map<String, Object> source;
        while ((source = reader.read()) != null) {
            assertTrue(source.get("field1").toString().startsWith("test"));
            valueSet.add(source.get("field1").toString());
            count++;
        }
        assertEquals(num, count);

     */
    public void setOutputEncoding(final String outputEncoding) {
        this.outputEncoding = outputEncoding;
    }

    /**
     * Sets whether to read content as text if extraction fails.
     * @param readAsTextIfFailed If true, read a content as a text when an extraction fails.
     */
    public void setReadAsTextIfFailed(final boolean readAsTextIfFailed) {
        this.readAsTextIfFailed = readAsTextIfFailed;