How to use

checkOffsetAndCount

method

in

com.lody.virtual.helper.utils.ArrayUtils

  /**
   * java.io always writes every byte it's asked to, or fails with an error. (That is, unlike
   * Unix it never just writes as many bytes as happens to be convenient.)
   */
  public static void write(FileDescriptor fd, byte[] bytes, int byteOffset, int byteCount) throws IOException {
    ArrayUtils.checkOffsetAndCount(bytes.length, byteOffset, byteCount);
    if (byteCount == 0) {
      return;
    }
    try {
      while (byteCount > 0) {
        int bytesWritten = Os.write(fd, bytes, byteOffset, byteCount);
        byteCount -= bytesWritten;
        byteOffset += bytesWritten;
      }
    } catch (ErrnoException errnoException) {
      throw new IOException(errnoException);
    }
  }
}

/**
 * java.io thinks that a read at EOF is an error and should return -1, contrary to traditional
 * Unix practice where you'd read until you got 0 bytes (and any future read would return -1).
 */
public static int read(FileDescriptor fd, byte[] bytes, int byteOffset, int byteCount) throws IOException {
  ArrayUtils.checkOffsetAndCount(bytes.length, byteOffset, byteCount);
  if (byteCount == 0) {
    return 0;
  }
  try {
    int readCount = Os.read(fd, bytes, byteOffset, byteCount);
    if (readCount == 0) {
      return -1;
    }
    return readCount;
  } catch (ErrnoException errnoException) {
    if (errnoException.errno == OsConstants.EAGAIN) {
      // We return 0 rather than throw if we try to read from an empty non-blocking pipe.
      return 0;
    }
    throw new IOException(errnoException);
  }
}

  /**
   * java.io always writes every byte it's asked to, or fails with an error. (That is, unlike
   * Unix it never just writes as many bytes as happens to be convenient.)
   */
  public static void write(FileDescriptor fd, byte[] bytes, int byteOffset, int byteCount) throws IOException {
    ArrayUtils.checkOffsetAndCount(bytes.length, byteOffset, byteCount);
    if (byteCount == 0) {
      return;
    }
    try {
      while (byteCount > 0) {
        int bytesWritten = Os.write(fd, bytes, byteOffset, byteCount);
        byteCount -= bytesWritten;
        byteOffset += bytesWritten;
      }
    } catch (ErrnoException errnoException) {
      throw new IOException(errnoException);
    }
  }
}

  /**
   * java.io always writes every byte it's asked to, or fails with an error. (That is, unlike
   * Unix it never just writes as many bytes as happens to be convenient.)
   */
  public static void write(FileDescriptor fd, byte[] bytes, int byteOffset, int byteCount) throws IOException {
    ArrayUtils.checkOffsetAndCount(bytes.length, byteOffset, byteCount);
    if (byteCount == 0) {
      return;
    }
    try {
      while (byteCount > 0) {
        int bytesWritten = Os.write(fd, bytes, byteOffset, byteCount);
        byteCount -= bytesWritten;
        byteOffset += bytesWritten;
      }
    } catch (ErrnoException errnoException) {
      throw new IOException(errnoException);
    }
  }
}

/**
 * java.io thinks that a read at EOF is an error and should return -1, contrary to traditional
 * Unix practice where you'd read until you got 0 bytes (and any future read would return -1).
 */
public static int read(FileDescriptor fd, byte[] bytes, int byteOffset, int byteCount) throws IOException {
  ArrayUtils.checkOffsetAndCount(bytes.length, byteOffset, byteCount);
  if (byteCount == 0) {
    return 0;
  }
  try {
    int readCount = Os.read(fd, bytes, byteOffset, byteCount);
    if (readCount == 0) {
      return -1;
    }
    return readCount;
  } catch (ErrnoException errnoException) {
    if (errnoException.errno == OsConstants.EAGAIN) {
      // We return 0 rather than throw if we try to read from an empty non-blocking pipe.
      return 0;
    }
    throw new IOException(errnoException);
  }
}

/**
 * java.io thinks that a read at EOF is an error and should return -1, contrary to traditional
 * Unix practice where you'd read until you got 0 bytes (and any future read would return -1).
 */
public static int read(FileDescriptor fd, byte[] bytes, int byteOffset, int byteCount) throws IOException {
  ArrayUtils.checkOffsetAndCount(bytes.length, byteOffset, byteCount);
  if (byteCount == 0) {
    return 0;
  }
  try {
    int readCount = Os.read(fd, bytes, byteOffset, byteCount);
    if (readCount == 0) {
      return -1;
    }
    return readCount;
  } catch (ErrnoException errnoException) {
    if (errnoException.errno == OsConstants.EAGAIN) {
      // We return 0 rather than throw if we try to read from an empty non-blocking pipe.
      return 0;
    }
    throw new IOException(errnoException);
  }
}