Rename kernel.pdf.ByteBuffer to ByteBufferOutputStream.

Author: pavel-alay

io/src/main/java/com/itextpdf/io/source/ByteBuffer.java

@@ -47,7 +47,7 @@ This file is part of the iText (R) project.
 import java.io.Serializable;
 import java.text.MessageFormat;
 
-public class ByteBuffer implements Serializable{
+public class ByteBuffer implements Serializable {
 
     private static final byte[] bytes = new byte[]{48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 97, 98, 99, 100, 101, 102};
 

kernel/src/main/java/com/itextpdf/kernel/pdf/ByteBuffer.java renamed to kernel/src/main/java/com/itextpdf/kernel/pdf/ByteBufferOutputStream.java

@@ -60,7 +60,7 @@
  * @author Paulo Soares
  */
 
-public class ByteBuffer extends OutputStream {
+public class ByteBufferOutputStream extends OutputStream {
     /** The count of bytes in the buffer. */
     protected int count;
 
@@ -80,16 +80,16 @@ public class ByteBuffer extends OutputStream {
     public static boolean HIGH_PRECISION = false;
     private static final DecimalFormatSymbols dfs = new DecimalFormatSymbols(Locale.US);
 
-    /** Creates new ByteBuffer with capacity 128 */
-    public ByteBuffer() {
+    /** Creates new ByteBufferOutputStream with capacity 128 */
+    public ByteBufferOutputStream() {
         this(128);
     }
 
     /**
      * Creates a byte buffer with a certain capacity.
      * @param size the initial capacity
      */
-    public ByteBuffer(int size) {
+    public ByteBufferOutputStream(int size) {
         if (size < 1)
             size = 128;
         buf = new byte[size];
@@ -181,9 +181,9 @@ private static byte[] convertToBytes(int i) {
     /**
      * Appends an <CODE>int</CODE>. The size of the array will grow by one.
      * @param b the int to be appended
-     * @return a reference to this <CODE>ByteBuffer</CODE> object
+     * @return a reference to this <CODE>ByteBufferOutputStream</CODE> object
      */
-    public ByteBuffer append_i(int b) {
+    public ByteBufferOutputStream append_i(int b) {
         int newcount = count + 1;
         if (newcount > buf.length) {
             byte[] newbuf = new byte[Math.max(buf.length << 1, newcount)];
@@ -201,9 +201,9 @@ public ByteBuffer append_i(int b) {
      * @param b the array to be appended
      * @param off the offset to the start of the array
      * @param len the length of bytes to append
-     * @return a reference to this <CODE>ByteBuffer</CODE> object
+     * @return a reference to this <CODE>ByteBufferOutputStream</CODE> object
      */
-    public ByteBuffer append(byte[] b, int off, int len) {
+    public ByteBufferOutputStream append(byte[] b, int off, int len) {
         if ((off < 0) || (off > b.length) || (len < 0) ||
         ((off + len) > b.length) || ((off + len) < 0) || len == 0)
             return this;
@@ -221,19 +221,19 @@ public ByteBuffer append(byte[] b, int off, int len) {
     /**
      * Appends an array of bytes.
      * @param b the array to be appended
-     * @return a reference to this <CODE>ByteBuffer</CODE> object
+     * @return a reference to this <CODE>ByteBufferOutputStream</CODE> object
      */
-    public ByteBuffer append(byte[] b) {
+    public ByteBufferOutputStream append(byte[] b) {
         return append(b, 0, b.length);
     }
 
     /**
      * Appends a <CODE>String</CODE> to the buffer. The <CODE>String</CODE> is
      * converted according to the encoding ISO-8859-1.
      * @param str the <CODE>String</CODE> to be appended
-     * @return a reference to this <CODE>ByteBuffer</CODE> object
+     * @return a reference to this <CODE>ByteBufferOutputStream</CODE> object
      */
-    public ByteBuffer append(String str) {
+    public ByteBufferOutputStream append(String str) {
         if (str != null)
             return append(str.getBytes());
         return this;
@@ -243,44 +243,44 @@ public ByteBuffer append(String str) {
      * Appends a <CODE>char</CODE> to the buffer. The <CODE>char</CODE> is
      * converted according to the encoding ISO-8859-1.
      * @param c the <CODE>char</CODE> to be appended
-     * @return a reference to this <CODE>ByteBuffer</CODE> object
+     * @return a reference to this <CODE>ByteBufferOutputStream</CODE> object
      */
-    public ByteBuffer append(char c) {
+    public ByteBufferOutputStream append(char c) {
         return append_i(c);
     }
 
     /**
-     * Appends another <CODE>ByteBuffer</CODE> to this buffer.
-     * @param buf the <CODE>ByteBuffer</CODE> to be appended
-     * @return a reference to this <CODE>ByteBuffer</CODE> object
+     * Appends another <CODE>ByteBufferOutputStream</CODE> to this buffer.
+     * @param buf the <CODE>ByteBufferOutputStream</CODE> to be appended
+     * @return a reference to this <CODE>ByteBufferOutputStream</CODE> object
      */
-    public ByteBuffer append(ByteBuffer buf) {
+    public ByteBufferOutputStream append(ByteBufferOutputStream buf) {
         return append(buf.buf, 0, buf.count);
     }
 
     /**
      * Appends the string representation of an <CODE>int</CODE>.
      * @param i the <CODE>int</CODE> to be appended
-     * @return a reference to this <CODE>ByteBuffer</CODE> object
+     * @return a reference to this <CODE>ByteBufferOutputStream</CODE> object
      */
-    public ByteBuffer append(int i) {
+    public ByteBufferOutputStream append(int i) {
         return append((double)i);
     }
 
     /**
      * Appends the string representation of a <CODE>long</CODE>.
      * @param i the <CODE>long</CODE> to be appended
-     * @return a reference to this <CODE>ByteBuffer</CODE> object
+     * @return a reference to this <CODE>ByteBufferOutputStream</CODE> object
      */
-    public ByteBuffer append(long i) {
+    public ByteBufferOutputStream append(long i) {
         return append(Long.toString(i));
     }
 
-    public ByteBuffer append(byte b) {
+    public ByteBufferOutputStream append(byte b) {
         return append_i(b);
     }
 
-    public ByteBuffer appendHex(byte b) {
+    public ByteBufferOutputStream appendHex(byte b) {
         append(bytes[(b >> 4) & 0x0f]);
         return append(bytes[b & 0x0f]);
     }
@@ -289,19 +289,19 @@ public ByteBuffer appendHex(byte b) {
      * Appends a string representation of a <CODE>float</CODE> according
      * to the Pdf conventions.
      * @param i the <CODE>float</CODE> to be appended
-     * @return a reference to this <CODE>ByteBuffer</CODE> object
+     * @return a reference to this <CODE>ByteBufferOutputStream</CODE> object
      */
-    public ByteBuffer append(float i) {
+    public ByteBufferOutputStream append(float i) {
         return append((double)i);
     }
 
     /**
      * Appends a string representation of a <CODE>double</CODE> according
      * to the Pdf conventions.
      * @param d the <CODE>double</CODE> to be appended
-     * @return a reference to this <CODE>ByteBuffer</CODE> object
+     * @return a reference to this <CODE>ByteBufferOutputStream</CODE> object
      */
-    public ByteBuffer append(double d) {
+    public ByteBufferOutputStream append(double d) {
         append(formatDouble(d, this));
         return this;
     }
@@ -318,12 +318,12 @@ public static String formatDouble(double d) {
     /**
      * Outputs a <CODE>double</CODE> into a format suitable for the PDF.
      * @param d a double
-     * @param buf a ByteBuffer
+     * @param buf a ByteBufferOutputStream
      * @return the <CODE>String</CODE> representation of the <CODE>double</CODE> if
      * <CODE>buf</CODE> is <CODE>null</CODE>. If <CODE>buf</CODE> is <B>not</B> <CODE>null</CODE>,
      * then the double is appended directly to the buffer and this methods returns <CODE>null</CODE>.
      */
-    public static String formatDouble(double d, ByteBuffer buf) {
+    public static String formatDouble(double d, ByteBufferOutputStream buf) {
         if (HIGH_PRECISION) {
             DecimalFormat dn = new DecimalFormat("0.######", dfs);
             String sform = dn.format(d);

kernel/src/main/java/com/itextpdf/kernel/pdf/PdfWriter.java

@@ -495,15 +495,15 @@ static class ByteStore {
         private final byte[] b;
         private final int hash;
         private MessageDigest md5;
-        private void serObject(PdfObject obj, int level, ByteBuffer bb, HashMap<Integer, Integer> serialized) {
+        private void serObject(PdfObject obj, int level, ByteBufferOutputStream bb, HashMap<Integer, Integer> serialized) {
             if (level <= 0)
                 return;
             if (obj == null) {
                 bb.append("$Lnull");
                 return;
             }
             PdfIndirectReference ref = null;
-            ByteBuffer savedBb = null;
+            ByteBufferOutputStream savedBb = null;
 
             if (obj.isIndirectReference()) {
                 ref = (PdfIndirectReference)obj;
@@ -514,7 +514,7 @@ private void serObject(PdfObject obj, int level, ByteBuffer bb, HashMap<Integer,
                 }
                 else {
                     savedBb = bb;
-                    bb = new ByteBuffer();
+                    bb = new ByteBufferOutputStream();
                 }
             }
 
@@ -549,22 +549,22 @@ else if (obj.isName()) {
             }
         }
 
-        private void serDic(PdfDictionary dic, int level, ByteBuffer bb, HashMap<Integer, Integer> serialized) {
+        private void serDic(PdfDictionary dic, int level, ByteBufferOutputStream bb, HashMap<Integer, Integer> serialized) {
             bb.append("$D");
             if (level <= 0)
                 return;
             Object[] keys = dic.keySet().toArray();
             Arrays.sort(keys);
-            for (int k = 0; k < keys.length; ++k) {
-                if(keys[k].equals(PdfName.P) &&(dic.get((PdfName)keys[k]).isIndirectReference() || dic.get((PdfName)keys[k]).isDictionary()) || keys[k].equals(PdfName.Parent)) // ignore recursive call
+            for (Object key : keys) {
+                if (key.equals(PdfName.P) && (dic.get((PdfName) key).isIndirectReference() || dic.get((PdfName) key).isDictionary()) || key.equals(PdfName.Parent)) // ignore recursive call
                     continue;
-                serObject((PdfObject) keys[k], level, bb, serialized);
-                serObject(dic.get((PdfName) keys[k], false), level, bb, serialized);
+                serObject((PdfObject) key, level, bb, serialized);
+                serObject(dic.get((PdfName) key, false), level, bb, serialized);
 
             }
         }
 
-        private void serArray(PdfArray array, int level, ByteBuffer bb, HashMap<Integer, Integer> serialized) {
+        private void serArray(PdfArray array, int level, ByteBufferOutputStream bb, HashMap<Integer, Integer> serialized) {
             bb.append("$A");
             if (level <= 0)
                 return;
@@ -580,7 +580,7 @@ private void serArray(PdfArray array, int level, ByteBuffer bb, HashMap<Integer,
             catch (Exception e) {
                 throw new PdfException(e);
             }
-            ByteBuffer bb = new ByteBuffer();
+            ByteBufferOutputStream bb = new ByteBufferOutputStream();
             int level = 100;
             serObject(str, level, bb, serialized);
             this.b = bb.toByteArray();
@@ -595,7 +595,7 @@ private void serArray(PdfArray array, int level, ByteBuffer bb, HashMap<Integer,
             catch (Exception e) {
                 throw new PdfException(e);
             }
-            ByteBuffer bb = new ByteBuffer();
+            ByteBufferOutputStream bb = new ByteBufferOutputStream();
             int level = 100;
             serObject(dict, level, bb, serialized);
             this.b = bb.toByteArray();
@@ -606,18 +606,16 @@ private void serArray(PdfArray array, int level, ByteBuffer bb, HashMap<Integer,
         private static int calculateHash(byte[] b) {
             int hash = 0;
             int len = b.length;
-            for (int k = 0; k < len; ++k)
+            for (int k = 0; k < len; ++k) {
                 hash = hash * 31 + (b[k] & 0xff);
+            }
             return hash;
         }
 
         @Override
         public boolean equals(Object obj) {
-            if (!(obj instanceof ByteStore))
-                return false;
-            if (hashCode() != obj.hashCode())
-                return false;
-            return Arrays.equals(b, ((ByteStore)obj).b);
+            return obj instanceof ByteStore &&
+                    hashCode() == obj.hashCode() && Arrays.equals(b, ((ByteStore) obj).b);
         }
 
         @Override