Categories:
Audio (13)
Biotech (29)
Bytecode (36)
Database (77)
Framework (7)
Game (7)
General (507)
Graphics (53)
I/O (35)
IDE (2)
JAR Tools (101)
JavaBeans (21)
JDBC (121)
JDK (426)
JSP (20)
Logging (108)
Mail (58)
Messaging (8)
Network (84)
PDF (97)
Report (7)
Scripting (84)
Security (32)
Server (121)
Servlet (26)
SOAP (24)
Testing (54)
Web (15)
XML (309)
Collections:
Other Resources:
JDK 17 java.base.jmod - Base Module
JDK 17 java.base.jmod is the JMOD file for JDK 17 Base module.
JDK 17 Base module compiled class files are stored in \fyicenter\jdk-17.0.5\jmods\java.base.jmod.
JDK 17 Base module compiled class files are also linked and stored in the \fyicenter\jdk-17.0.5\lib\modules JImage file.
JDK 17 Base module source code files are stored in \fyicenter\jdk-17.0.5\lib\src.zip\java.base.
You can click and view the content of each source code file in the list below.
✍: FYIcenter
⏎ java/io/BufferedInputStream.java
/* * Copyright (c) 1994, 2020, Oracle and/or its affiliates. All rights reserved. * ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms. * * * * * * * * * * * * * * * * * * * * */ package java.io; import jdk.internal.misc.Unsafe; import jdk.internal.util.ArraysSupport; /** * A {@code BufferedInputStream} adds * functionality to another input stream-namely, * the ability to buffer the input and to * support the {@code mark} and {@code reset} * methods. When the {@code BufferedInputStream} * is created, an internal buffer array is * created. As bytes from the stream are read * or skipped, the internal buffer is refilled * as necessary from the contained input stream, * many bytes at a time. The {@code mark} * operation remembers a point in the input * stream and the {@code reset} operation * causes all the bytes read since the most * recent {@code mark} operation to be * reread before new bytes are taken from * the contained input stream. * * @author Arthur van Hoff * @since 1.0 */ public class BufferedInputStream extends FilterInputStream { private static int DEFAULT_BUFFER_SIZE = 8192; /** * As this class is used early during bootstrap, it's motivated to use * Unsafe.compareAndSetObject instead of AtomicReferenceFieldUpdater * (or VarHandles) to reduce dependencies and improve startup time. */ private static final Unsafe U = Unsafe.getUnsafe(); private static final long BUF_OFFSET = U.objectFieldOffset(BufferedInputStream.class, "buf"); /** * The internal buffer array where the data is stored. When necessary, * it may be replaced by another array of * a different size. */ /* * We null this out with a CAS on close(), which is necessary since * closes can be asynchronous. We use nullness of buf[] as primary * indicator that this stream is closed. (The "in" field is also * nulled out on close.) */ protected volatile byte[] buf; /** * The index one greater than the index of the last valid byte in * the buffer. * This value is always * in the range {@code 0} through {@code buf.length}; * elements {@code buf[0]} through {@code buf[count-1]} * contain buffered input data obtained * from the underlying input stream. */ protected int count; /** * The current position in the buffer. This is the index of the next * character to be read from the {@code buf} array. * <p> * This value is always in the range {@code 0} * through {@code count}. If it is less * than {@code count}, then {@code buf[pos]} * is the next byte to be supplied as input; * if it is equal to {@code count}, then * the next {@code read} or {@code skip} * operation will require more bytes to be * read from the contained input stream. * * @see java.io.BufferedInputStream#buf */ protected int pos; /** * The value of the {@code pos} field at the time the last * {@code mark} method was called. * <p> * This value is always * in the range {@code -1} through {@code pos}. * If there is no marked position in the input * stream, this field is {@code -1}. If * there is a marked position in the input * stream, then {@code buf[markpos]} * is the first byte to be supplied as input * after a {@code reset} operation. If * {@code markpos} is not {@code -1}, * then all bytes from positions {@code buf[markpos]} * through {@code buf[pos-1]} must remain * in the buffer array (though they may be * moved to another place in the buffer array, * with suitable adjustments to the values * of {@code count}, {@code pos}, * and {@code markpos}); they may not * be discarded unless and until the difference * between {@code pos} and {@code markpos} * exceeds {@code marklimit}. * * @see java.io.BufferedInputStream#mark(int) * @see java.io.BufferedInputStream#pos */ protected int markpos = -1; /** * The maximum read ahead allowed after a call to the * {@code mark} method before subsequent calls to the * {@code reset} method fail. * Whenever the difference between {@code pos} * and {@code markpos} exceeds {@code marklimit}, * then the mark may be dropped by setting * {@code markpos} to {@code -1}. * * @see java.io.BufferedInputStream#mark(int) * @see java.io.BufferedInputStream#reset() */ protected int marklimit; /** * Check to make sure that underlying input stream has not been * nulled out due to close; if not return it; */ private InputStream getInIfOpen() throws IOException { InputStream input = in; if (input == null) throw new IOException("Stream closed"); return input; } /** * Check to make sure that buffer has not been nulled out due to * close; if not return it; */ private byte[] getBufIfOpen() throws IOException { byte[] buffer = buf; if (buffer == null) throw new IOException("Stream closed"); return buffer; } /** * Creates a {@code BufferedInputStream} * and saves its argument, the input stream * {@code in}, for later use. An internal * buffer array is created and stored in {@code buf}. * * @param in the underlying input stream. */ public BufferedInputStream(InputStream in) { this(in, DEFAULT_BUFFER_SIZE); } /** * Creates a {@code BufferedInputStream} * with the specified buffer size, * and saves its argument, the input stream * {@code in}, for later use. An internal * buffer array of length {@code size} * is created and stored in {@code buf}. * * @param in the underlying input stream. * @param size the buffer size. * @throws IllegalArgumentException if {@code size <= 0}. */ public BufferedInputStream(InputStream in, int size) { super(in); if (size <= 0) { throw new IllegalArgumentException("Buffer size <= 0"); } buf = new byte[size]; } /** * Fills the buffer with more data, taking into account * shuffling and other tricks for dealing with marks. * Assumes that it is being called by a synchronized method. * This method also assumes that all data has already been read in, * hence pos > count. */ private void fill() throws IOException { byte[] buffer = getBufIfOpen(); if (markpos < 0) pos = 0; /* no mark: throw away the buffer */ else if (pos >= buffer.length) { /* no room left in buffer */ if (markpos > 0) { /* can throw away early part of the buffer */ int sz = pos - markpos; System.arraycopy(buffer, markpos, buffer, 0, sz); pos = sz; markpos = 0; } else if (buffer.length >= marklimit) { markpos = -1; /* buffer got too big, invalidate mark */ pos = 0; /* drop buffer contents */ } else { /* grow buffer */ int nsz = ArraysSupport.newLength(pos, 1, /* minimum growth */ pos /* preferred growth */); if (nsz > marklimit) nsz = marklimit; byte[] nbuf = new byte[nsz]; System.arraycopy(buffer, 0, nbuf, 0, pos); if (!U.compareAndSetReference(this, BUF_OFFSET, buffer, nbuf)) { // Can't replace buf if there was an async close. // Note: This would need to be changed if fill() // is ever made accessible to multiple threads. // But for now, the only way CAS can fail is via close. // assert buf == null; throw new IOException("Stream closed"); } buffer = nbuf; } } count = pos; int n = getInIfOpen().read(buffer, pos, buffer.length - pos); if (n > 0) count = n + pos; } /** * See * the general contract of the {@code read} * method of {@code InputStream}. * * @return the next byte of data, or {@code -1} if the end of the * stream is reached. * @throws IOException if this input stream has been closed by * invoking its {@link #close()} method, * or an I/O error occurs. * @see java.io.FilterInputStream#in */ public synchronized int read() throws IOException { if (pos >= count) { fill(); if (pos >= count) return -1; } return getBufIfOpen()[pos++] & 0xff; } /** * Read characters into a portion of an array, reading from the underlying * stream at most once if necessary. */ private int read1(byte[] b, int off, int len) throws IOException { int avail = count - pos; if (avail <= 0) { /* If the requested length is at least as large as the buffer, and if there is no mark/reset activity, do not bother to copy the bytes into the local buffer. In this way buffered streams will cascade harmlessly. */ if (len >= getBufIfOpen().length && markpos < 0) { return getInIfOpen().read(b, off, len); } fill(); avail = count - pos; if (avail <= 0) return -1; } int cnt = (avail < len) ? avail : len; System.arraycopy(getBufIfOpen(), pos, b, off, cnt); pos += cnt; return cnt; } /** * Reads bytes from this byte-input stream into the specified byte array, * starting at the given offset. * * <p> This method implements the general contract of the corresponding * {@link InputStream#read(byte[], int, int) read} method of * the {@link InputStream} class. As an additional * convenience, it attempts to read as many bytes as possible by repeatedly * invoking the {@code read} method of the underlying stream. This * iterated {@code read} continues until one of the following * conditions becomes true: <ul> * * <li> The specified number of bytes have been read, * * <li> The {@code read} method of the underlying stream returns * {@code -1}, indicating end-of-file, or * * <li> The {@code available} method of the underlying stream * returns zero, indicating that further input requests would block. * * </ul> If the first {@code read} on the underlying stream returns * {@code -1} to indicate end-of-file then this method returns * {@code -1}. Otherwise this method returns the number of bytes * actually read. * * <p> Subclasses of this class are encouraged, but not required, to * attempt to read as many bytes as possible in the same fashion. * * @param b destination buffer. * @param off offset at which to start storing bytes. * @param len maximum number of bytes to read. * @return the number of bytes read, or {@code -1} if the end of * the stream has been reached. * @throws IOException if this input stream has been closed by * invoking its {@link #close()} method, * or an I/O error occurs. */ public synchronized int read(byte b[], int off, int len) throws IOException { getBufIfOpen(); // Check for closed stream if ((off | len | (off + len) | (b.length - (off + len))) < 0) { throw new IndexOutOfBoundsException(); } else if (len == 0) { return 0; } int n = 0; for (;;) { int nread = read1(b, off + n, len - n); if (nread <= 0) return (n == 0) ? nread : n; n += nread; if (n >= len) return n; // if not closed but no bytes available, return InputStream input = in; if (input != null && input.available() <= 0) return n; } } /** * See the general contract of the {@code skip} * method of {@code InputStream}. * * @throws IOException if this input stream has been closed by * invoking its {@link #close()} method, * {@code in.skip(n)} throws an IOException, * or an I/O error occurs. */ public synchronized long skip(long n) throws IOException { getBufIfOpen(); // Check for closed stream if (n <= 0) { return 0; } long avail = count - pos; if (avail <= 0) { // If no mark position set then don't keep in buffer if (markpos <0) return getInIfOpen().skip(n); // Fill in buffer to save bytes for reset fill(); avail = count - pos; if (avail <= 0) return 0; } long skipped = (avail < n) ? avail : n; pos += skipped; return skipped; } /** * Returns an estimate of the number of bytes that can be read (or * skipped over) from this input stream without blocking by the next * invocation of a method for this input stream. The next invocation might be * the same thread or another thread. A single read or skip of this * many bytes will not block, but may read or skip fewer bytes. * <p> * This method returns the sum of the number of bytes remaining to be read in * the buffer ({@code count - pos}) and the result of calling the * {@link java.io.FilterInputStream#in in}{@code .available()}. * * @return an estimate of the number of bytes that can be read (or skipped * over) from this input stream without blocking. * @throws IOException if this input stream has been closed by * invoking its {@link #close()} method, * or an I/O error occurs. */ public synchronized int available() throws IOException { int n = count - pos; int avail = getInIfOpen().available(); return n > (Integer.MAX_VALUE - avail) ? Integer.MAX_VALUE : n + avail; } /** * See the general contract of the {@code mark} * method of {@code InputStream}. * * @param readlimit the maximum limit of bytes that can be read before * the mark position becomes invalid. * @see java.io.BufferedInputStream#reset() */ public synchronized void mark(int readlimit) { marklimit = readlimit; markpos = pos; } /** * See the general contract of the {@code reset} * method of {@code InputStream}. * <p> * If {@code markpos} is {@code -1} * (no mark has been set or the mark has been * invalidated), an {@code IOException} * is thrown. Otherwise, {@code pos} is * set equal to {@code markpos}. * * @throws IOException if this stream has not been marked or, * if the mark has been invalidated, or the stream * has been closed by invoking its {@link #close()} * method, or an I/O error occurs. * @see java.io.BufferedInputStream#mark(int) */ public synchronized void reset() throws IOException { getBufIfOpen(); // Cause exception if closed if (markpos < 0) throw new IOException("Resetting to invalid mark"); pos = markpos; } /** * Tests if this input stream supports the {@code mark} * and {@code reset} methods. The {@code markSupported} * method of {@code BufferedInputStream} returns * {@code true}. * * @return a {@code boolean} indicating if this stream type supports * the {@code mark} and {@code reset} methods. * @see java.io.InputStream#mark(int) * @see java.io.InputStream#reset() */ public boolean markSupported() { return true; } /** * Closes this input stream and releases any system resources * associated with the stream. * Once the stream has been closed, further read(), available(), reset(), * or skip() invocations will throw an IOException. * Closing a previously closed stream has no effect. * * @throws IOException if an I/O error occurs. */ public void close() throws IOException { byte[] buffer; while ( (buffer = buf) != null) { if (U.compareAndSetReference(this, BUF_OFFSET, buffer, null)) { InputStream input = in; in = null; if (input != null) input.close(); return; } // Else retry in case a new buf was CASed in fill() } } }
⏎ java/io/BufferedInputStream.java
Or download all of them as a single archive file:
File name: java.base-17.0.5-src.zip File size: 8883851 bytes Release date: 2022-09-13 Download
2023-09-26, 93418👍, 1💬
Popular Posts:
maven-settings-builder-3 .8.6.jaris the JAR file for Apache Maven 3.8.6 Settings Builder module. Apa...
Apache Ant is a Java-based build tool. In theory, it is kind of like make, without make's wrinkles. ...
Smack is an Open Source XMPP (Jabber) client library for instant messaging and presence. A pure Java...
Guava is a suite of core and expanded libraries that include utility classes, google's collections, ...
What Is ojdbc8.jar for Oracle 12c R2? ojdbc8.jar for Oracle 12c R2 is the JAR files of ojdbc.jar, JD...