char[] buf = new char[DEFAULT_BUF_SIZE];
    int nRead;
    long total = 0;
    while ((nRead = from.read(buf)) != -1) {
      to.write(buf, 0, nRead);
      total += nRead;
    }
    return total;
  }

  /**
   * Reads all characters from a {@link Readable} object into a {@link String}. Does not close the
   * {@code Readable}.
   *
   * @param r the object to read from

        b += 2 // We rewound two bytes and then added four.
        break
      } else {
        return null // Wrong delimiter.
      }
    }

    // Read a group, one to four hex digits.
    var value = 0
    groupOffset = i
    while (i < limit) {
      val hexDigit = input[i].parseHexDigit()
      if (hexDigit == -1) break
      value = (value shl 4) + hexDigit
      i++
    }

 *       block indefinitely or fail if the source creates an infinite reader.
 *   <li><b>Non-destructive:</b> A <i>destructive</i> reader will consume or otherwise alter the
 *       source as they are read from it. A source that provides such readers will not be reusable,
 *       and operations that read from the stream (including {@link #length()}, in some

 *       block indefinitely or fail if the source creates an infinite reader.
 *   <li><b>Non-destructive:</b> A <i>destructive</i> reader will consume or otherwise alter the
 *       source as they are read from it. A source that provides such readers will not be reusable,
 *       and operations that read from the stream (including {@link #length()}, in some

      frameCallback.onReadMessage(messageFrameBuffer.readByteString())
    }
  }

  /** Read headers and process any control frames until we reach a non-control frame. */
  @Throws(IOException::class)
  private fun readUntilNonControlFrame() {
    while (!closed) {
      readHeader()
      if (!isControlFrame) {
        break
      }
      readControlFrame()
    }
  }

  /**

                removeWaiter(node);
                break long_wait_loop; // jump down to the busy wait loop
              }
            }
          }
          oldHead = waitersField; // re-read and loop.
        } while (oldHead != Waiter.TOMBSTONE);
      }
      // re-read valueField, if we get here then we must have observed a TOMBSTONE while trying to
      // add a waiter.

                removeWaiter(node);
                break long_wait_loop; // jump down to the busy wait loop
              }
            }
          }
          oldHead = waitersField; // re-read and loop.
        } while (oldHead != Waiter.TOMBSTONE);
      }
      // re-read valueField, if we get here then we must have observed a TOMBSTONE while trying to
      // add a waiter.

    /** The next byte to read. This is always less than or equal to [upstreamPos]. */
    private var sourcePos = 0L

    /**
     * Selects where to find the bytes for a read and read them. This is one of three sources.
     *
     * ## Upstream
     *
     * In this case the current thread is assigned as the upstream reader. We read bytes from

            shift += 7
          } else {
            result += b shl shift // Last byte.
            break
          }
        }
        return result
      }

      /** Reads a potentially Huffman encoded byte string. */
      @Throws(IOException::class)
      fun readByteString(): ByteString {
        val firstByte = readByte()

        listeners.enqueue(TERMINATED_FROM_NEW_EVENT);
        break;
      case STARTING:
        listeners.enqueue(TERMINATED_FROM_STARTING_EVENT);
        break;
      case RUNNING:
        listeners.enqueue(TERMINATED_FROM_RUNNING_EVENT);
        break;
      case STOPPING:
        listeners.enqueue(TERMINATED_FROM_STOPPING_EVENT);
        break;
      case TERMINATED:
      case FAILED: