internal inline fun ignoreIoExceptions(block: () -> Unit) {
  try {
    block()
  } catch (_: IOException) {
  }
}

internal fun Buffer.skipAll(b: Byte): Int {
  var count = 0
  while (!exhausted() && this[0] == b) {
    count++
    readByte()
  }
  return count
}

/**
 * Returns the index of the next non-whitespace character in this. Result is undefined if input

                result[ri] = path.substring(b, i);
                ri++;
                strip++;
                b = i + 1;
            }
        } while (i++ < len);

        while (ri < result.length) {
            result[ri] = "";
            ri++;
        }

        return strip;
    }

        buffer.putInt(FileNotifyInformation.FILE_ACTION_ADDED);
        buffer.putInt(fileNameBytes1.length);
        buffer.put(fileNameBytes1);

        // Pad to aligned size
        while (buffer.position() < entry1AlignedSize) {
            buffer.put((byte) 0);
        }

        // Second notification
        buffer.putInt(entry2AlignedSize); // nextEntryOffset

    lines['status'] = InvokeStatus.passed  # default to passed
    start_line = lines['start']
    end_line = lines.get('end', lines.get('next_url', len(log_lines))) - 1
    k = end_line
    while k > start_line:
      backtrack_line = log_lines[k]
      build_failed = backtrack_line.startswith(FAILED_BUILD_LINE)
      if build_failed or not backtrack_line.startswith(BUILD_STATUS_LINE):
        tests_failed = False

     * CRC(A000A000A000...), CRC(0B000B000B...), CRC(00C000C000C...), CRC(000D000D000D...)
     * and then to XOR them together.  The strideTable enables us to hash an int followed by 12
     * zero bytes (3 ints), while the byteTable is for advancing one byte at a time.
     * This algorithm is due to the paper "Everything we know about CRC but [are] afraid to forget"
     * by Kadatch and Jenkins, 2010.
     */

    Crc32cHasher() {

        method.setAccessible(true);
        return (FileEntry[]) method.invoke(response);
    }

    private Method getReadStringMethod() throws Exception {
        Class<?> clazz = response.getClass();
        while (clazz != null) {
            try {
                Method method = clazz.getDeclaredMethod("readString", byte[].class, int.class, int.class, boolean.class);
                method.setAccessible(true);

      sort(ranges, Range.rangeLexOrdering());
      PeekingIterator<Range<C>> peekingItr = Iterators.peekingIterator(ranges.iterator());
      while (peekingItr.hasNext()) {
        Range<C> range = peekingItr.next();
        while (peekingItr.hasNext()) {
          Range<C> nextRange = peekingItr.peek();
          if (range.isConnected(nextRange)) {
            checkArgument(

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Map;

/**
 * A specialized ArrayList for storing document data with additional metadata.
 * This class extends ArrayList to hold document maps while tracking content size
 * and processing time metrics. It's used throughout the Fess search system to
 * manage collections of search results and crawled documents.
 *
 */

  }

  /** Sleeps [nanos], throwing if the socket is closed before that period has elapsed. */
  fun sleepWhileOpen(nanos: Long) {
    var ms = nanos / 1_000_000L
    val ns = nanos - (ms * 1_000_000L)

    while (ms > 100) {
      Thread.sleep(100)
      if (javaNetSocket.isClosed) throw InterruptedIOException("socket closed")
      ms -= 100L
    }

    if (ms > 0L || ns > 0) {
      Thread.sleep(ms, ns.toInt())

        int elemStart = bufferOffset;
        FileNotifyInformationImpl i = new FileNotifyInformationImpl();
        bufferIndex += i.decode(buffer, bufferOffset, len);
        this.notifyInformation.add(i);

        while (i.getNextEntryOffset() > 0 && bufferIndex < bufferOffset + len) {
            bufferIndex = elemStart + i.getNextEntryOffset();
            elemStart = bufferIndex;

            i = new FileNotifyInformationImpl();