< prev index next >

src/java.desktop/share/classes/javax/imageio/stream/MemoryCache.java

Print this page

        

@@ -30,31 +30,31 @@
 import java.io.OutputStream;
 import java.io.IOException;
 
 /**
  * Package-visible class consolidating common code for
- * <code>MemoryCacheImageInputStream</code> and
- * <code>MemoryCacheImageOutputStream</code>.
- * This class keeps an <code>ArrayList</code> of 8K blocks,
+ * {@code MemoryCacheImageInputStream} and
+ * {@code MemoryCacheImageOutputStream}.
+ * This class keeps an {@code ArrayList} of 8K blocks,
  * loaded sequentially.  Blocks may only be disposed of
  * from the index 0 forward.  As blocks are freed, the
  * corresponding entries in the array list are set to
- * <code>null</code>, but no compacting is performed.
+ * {@code null}, but no compacting is performed.
  * This allows the index for each block to never change,
  * and the length of the cache is always the same as the
  * total amount of data ever cached.  Cached data is
  * therefore always contiguous from the point of last
  * disposal to the current length.
  *
  * <p> The total number of blocks resident in the cache must not
- * exceed <code>Integer.MAX_VALUE</code>.  In practice, the limit of
+ * exceed {@code Integer.MAX_VALUE}.  In practice, the limit of
  * available memory will be exceeded long before this becomes an
  * issue, since a full cache would contain 8192*2^31 = 16 terabytes of
  * data.
  *
- * A <code>MemoryCache</code> may be reused after a call
- * to <code>reset()</code>.
+ * A {@code MemoryCache} may be reused after a call
+ * to {@code reset()}.
  */
 class MemoryCache {
 
     private static final int BUFFER_LENGTH = 8192;
 

@@ -76,13 +76,13 @@
         }
         return cache.get((int)blockOffset);
     }
 
     /**
-     * Ensures that at least <code>pos</code> bytes are cached,
+     * Ensures that at least {@code pos} bytes are cached,
      * or the end of the source is reached.  The return value
-     * is equal to the smaller of <code>pos</code> and the
+     * is equal to the smaller of {@code pos} and the
      * length of the source.
      *
      * @throws IOException if there is no more memory for cache
      */
     public long loadFromStream(InputStream stream, long pos)

@@ -134,19 +134,19 @@
 
         return pos;
     }
 
     /**
-     * Writes out a portion of the cache to an <code>OutputStream</code>.
+     * Writes out a portion of the cache to an {@code OutputStream}.
      * This method preserves no state about the output stream, and does
      * not dispose of any blocks containing bytes written.  To dispose
-     * blocks, use {@link #disposeBefore <code>disposeBefore()</code>}.
+     * blocks, use {@link #disposeBefore disposeBefore()}.
      *
      * @exception IndexOutOfBoundsException if any portion of
-     * the requested data is not in the cache (including if <code>pos</code>
-     * is in a block already disposed), or if either <code>pos</code> or
-     * <code>len</code> is < 0.
+     * the requested data is not in the cache (including if {@code pos}
+     * is in a block already disposed), or if either {@code pos} or
+     * {@code len} is < 0.
      * @throws IOException if there is an I/O exception while writing to the
      * stream
      */
     public void writeToStream(OutputStream stream, long pos, long len)
         throws IOException {

@@ -205,14 +205,14 @@
      * @param b an array of bytes containing data to be written.
      * @param off the starting offset within the data array.
      * @param len the number of bytes to be written.
      * @param pos the cache position at which to begin writing.
      *
-     * @exception NullPointerException if <code>b</code> is <code>null</code>.
-     * @exception IndexOutOfBoundsException if <code>off</code>,
-     * <code>len</code>, or <code>pos</code> are negative,
-     * or if <code>off+len > b.length</code>.
+     * @exception NullPointerException if {@code b} is {@code null}.
+     * @exception IndexOutOfBoundsException if {@code off},
+     * {@code len}, or {@code pos} are negative,
+     * or if {@code off+len > b.length}.
      * @throws IOException if there is an I/O error while writing to the cache
      */
     public void write(byte[] b, int off, int len, long pos)
         throws IOException {
         if (b == null) {

@@ -248,15 +248,15 @@
     /**
      * Overwrites or appends a single byte to the cache.
      * The length of the cache will be extended as needed to hold
      * the incoming data.
      *
-     * @param b an <code>int</code> whose 8 least significant bits
+     * @param b an {@code int} whose 8 least significant bits
      * will be written.
      * @param pos the cache position at which to begin writing.
      *
-     * @exception IndexOutOfBoundsException if <code>pos</code> is negative.
+     * @exception IndexOutOfBoundsException if {@code pos} is negative.
      * @throws IOException if there is an I/O error while writing to the cache
      */
     public void write(int b, long pos) throws IOException {
         if (pos < 0) {
             throw new ArrayIndexOutOfBoundsException("pos < 0");

@@ -283,11 +283,11 @@
         return length;
     }
 
     /**
      * Returns the single byte at the given position, as an
-     * <code>int</code>.  Returns -1 if this position has
+     * {@code int}.  Returns -1 if this position has
      * not been cached or has been disposed.
      *
      * @throws IOException if an I/O error occurs while reading from the byte
      * array
      */

@@ -303,20 +303,20 @@
 
         return buf[(int)(pos % BUFFER_LENGTH)] & 0xff;
     }
 
     /**
-     * Copy <code>len</code> bytes from the cache, starting
-     * at cache position <code>pos</code>, into the array
-     * <code>b</code> at offset <code>off</code>.
-     *
-     * @exception NullPointerException if b is <code>null</code>
-     * @exception IndexOutOfBoundsException if <code>off</code>,
-     * <code>len</code> or <code>pos</code> are negative or if
-     * <code>off + len > b.length</code> or if any portion of the
+     * Copy {@code len} bytes from the cache, starting
+     * at cache position {@code pos}, into the array
+     * {@code b} at offset {@code off}.
+     *
+     * @exception NullPointerException if b is {@code null}
+     * @exception IndexOutOfBoundsException if {@code off},
+     * {@code len} or {@code pos} are negative or if
+     * {@code off + len > b.length} or if any portion of the
      * requested data is not in the cache (including if
-     * <code>pos</code> is in a block that has already been disposed).
+     * {@code pos} is in a block that has already been disposed).
      * @throws IOException if an I/O exception occurs while reading from the
      * byte array
      */
     public void read(byte[] b, int off, int len, long pos)
         throws IOException {

@@ -344,14 +344,14 @@
             offset = 0; // Always after the first time
         }
     }
 
     /**
-     * Free the blocks up to the position <code>pos</code>.
-     * The byte at <code>pos</code> remains available.
+     * Free the blocks up to the position {@code pos}.
+     * The byte at {@code pos} remains available.
      *
-     * @exception IndexOutOfBoundsException if <code>pos</code>
+     * @exception IndexOutOfBoundsException if {@code pos}
      * is in a block that has already been disposed.
      */
     public void disposeBefore(long pos) {
         long index = pos/BUFFER_LENGTH;
         if (index < cacheStart) {
< prev index next >