Mailing-List: contact commits-help@mina.apache.org; run by ezmlm
Precedence: bulk
Reply-To: dev@mina.apache.org
Content-Type: text/plain; charset="utf-8"
MIME-Version: 1.0
Content-Transfer-Encoding: 7bit
Subject: svn commit: r546356 -
 /mina/trunk/core/src/main/java/org/apache/mina/common/ByteBuffer.java
Date: Tue, 12 Jun 2007 02:07:30 -0000
To: commits@mina.apache.org
From: trustin@apache.org
Message-Id: <20070612020730.7DEFF1A981A@eris.apache.org>

Author: trustin
Date: Mon Jun 11 19:07:29 2007
New Revision: 546356

URL: http://svn.apache.org/viewvc?view=rev&rev=546356
Log:
* Applied invocation chaining to get/putEnum methods
* Added random access version of get/putEnumSet methods

Modified:
    mina/trunk/core/src/main/java/org/apache/mina/common/ByteBuffer.java

Modified: mina/trunk/core/src/main/java/org/apache/mina/common/ByteBuffer.java
URL: http://svn.apache.org/viewvc/mina/trunk/core/src/main/java/org/apache/mina/common/ByteBuffer.java?view=diff&rev=546356&r1=546355&r2=546356
==============================================================================
--- mina/trunk/core/src/main/java/org/apache/mina/common/ByteBuffer.java (original)
+++ mina/trunk/core/src/main/java/org/apache/mina/common/ByteBuffer.java Mon Jun 11 19:07:29 2007
@@ -1953,6 +1953,19 @@
     }
 
     /**
+     * Reads a byte from the buffer and returns the correlating enum constant defined
+     * by the specified enum type.
+     * 
+     * @param <E> The enum type to return
+     * @param index  the index from which the byte will be read
+     * @param enumClass  The enum's class object
+     * @return  
+     */
+    public <E extends Enum<E>> E getEnum(int index, Class<E> enumClass) {
+        return toEnum(enumClass, get(index));
+    }
+
+    /**
      * Reads a short from the buffer and returns the correlating enum constant defined
      * by the specified enum type.
      * 
@@ -1965,6 +1978,19 @@
     }
 
     /**
+     * Reads a short from the buffer and returns the correlating enum constant defined
+     * by the specified enum type.
+     * 
+     * @param <E> The enum type to return
+     * @param index  the index from which the bytes will be read
+     * @param enumClass  The enum's class object
+     * @return  
+     */
+    public <E extends Enum<E>> E getEnumShort(int index, Class<E> enumClass) {
+        return toEnum(enumClass, getShort(index));
+    }
+
+    /**
      * Reads an int from the buffer and returns the correlating enum constant defined
      * by the specified enum type.
      * 
@@ -1977,15 +2003,41 @@
     }
     
     /**
+     * Reads an int from the buffer and returns the correlating enum constant defined
+     * by the specified enum type.
+     * 
+     * @param <E> The enum type to return
+     * @param index  the index from which the bytes will be read
+     * @param enumClass  The enum's class object
+     * @return  
+     */
+    public <E extends Enum<E>> E getEnumInt(int index, Class<E> enumClass) {
+        return toEnum(enumClass, getInt(index));
+    }
+    
+    /**
      * Writes an enum's ordinal value to the buffer as a byte.
      * 
      * @param e  The enum to write to the buffer
      */
-    public void putEnum(Enum e) {
+    public ByteBuffer putEnum(Enum e) {
+        if (e.ordinal() > Byte.MAX_VALUE) {
+            throw new IllegalArgumentException(enumConversionErrorMessage(e, "byte"));
+        }
+        return put((byte)e.ordinal());
+    }
+
+    /**
+     * Writes an enum's ordinal value to the buffer as a byte.
+     *
+     * @param index The index at which the byte will be written
+     * @param e  The enum to write to the buffer
+     */
+    public ByteBuffer putEnum(int index, Enum e) {
         if (e.ordinal() > Byte.MAX_VALUE) {
             throw new IllegalArgumentException(enumConversionErrorMessage(e, "byte"));
         }
-        put((byte)e.ordinal());
+        return put(index, (byte)e.ordinal());
     }
 
     /**
@@ -1993,11 +2045,24 @@
      * 
      * @param e  The enum to write to the buffer
      */
-    public void putEnumShort(Enum e) {
+    public ByteBuffer putEnumShort(Enum e) {
+        if (e.ordinal() > Short.MAX_VALUE) {
+            throw new IllegalArgumentException(enumConversionErrorMessage(e, "short"));
+        }
+        return putShort((short)e.ordinal());
+    }
+    
+    /**
+     * Writes an enum's ordinal value to the buffer as a short.
+     * 
+     * @param index The index at which the bytes will be written
+     * @param e  The enum to write to the buffer
+     */
+    public ByteBuffer putEnumShort(int index, Enum e) {
         if (e.ordinal() > Short.MAX_VALUE) {
             throw new IllegalArgumentException(enumConversionErrorMessage(e, "short"));
         }
-        putShort((short)e.ordinal());
+        return putShort(index, (short)e.ordinal());
     }
     
     /**
@@ -2005,8 +2070,18 @@
      * 
      * @param e  The enum to write to the buffer
      */
-    public void putEnumInt(Enum e) {
-        putInt(e.ordinal());
+    public ByteBuffer putEnumInt(Enum e) {
+        return putInt(e.ordinal());
+    }
+
+    /**
+     * Writes an enum's ordinal value to the buffer as an integer.
+     * 
+     * @param index The index at which the bytes will be written
+     * @param e  The enum to write to the buffer
+     */
+    public ByteBuffer putEnumInt(int index, Enum e) {
+        return putInt(index, e.ordinal());
     }
 
     private <E> E toEnum(Class<E> enumClass, int i) {
@@ -2045,6 +2120,19 @@
     }
 
     /**
+     * Reads a byte sized bit vector and converts it to an {@link EnumSet}.
+     * 
+     * @see #getEnumSet(Class)
+     * @param <E>  the enum type
+     * @param index  the index from which the byte will be read
+     * @param enumClass  the enum class used to create the EnumSet
+     * @return the EnumSet representation of the bit vector
+     */
+    public <E extends Enum<E>> EnumSet<E> getEnumSet(int index, Class<E> enumClass) {
+        return toEnumSet(enumClass, get(index) & BYTE_MASK);
+    }
+
+    /**
      * Reads a short sized bit vector and converts it to an {@link EnumSet}.
      * 
      * @see #getEnumSet(Class)
@@ -2057,6 +2145,19 @@
     }
 
     /**
+     * Reads a short sized bit vector and converts it to an {@link EnumSet}.
+     * 
+     * @see #getEnumSet(Class)
+     * @param <E>  the enum type
+     * @param index  the index from which the bytes will be read
+     * @param enumClass  the enum class used to create the EnumSet
+     * @return the EnumSet representation of the bit vector
+     */
+    public <E extends Enum<E>> EnumSet<E> getEnumSetShort(int index, Class<E> enumClass) {
+        return toEnumSet(enumClass, getShort(index) & SHORT_MASK);
+    }
+
+    /**
      * Reads an int sized bit vector and converts it to an {@link EnumSet}.
      * 
      * @see #getEnumSet(Class)
@@ -2069,6 +2170,19 @@
     }
 
     /**
+     * Reads an int sized bit vector and converts it to an {@link EnumSet}.
+     * 
+     * @see #getEnumSet(Class)
+     * @param <E>  the enum type
+     * @param index  the index from which the bytes will be read
+     * @param enumClass  the enum class used to create the EnumSet
+     * @return the EnumSet representation of the bit vector
+     */
+    public <E extends Enum<E>> EnumSet<E> getEnumSetInt(int index, Class<E> enumClass) {
+        return toEnumSet(enumClass, getInt(index) & INT_MASK);
+    }
+
+    /**
      * Reads a long sized bit vector and converts it to an {@link EnumSet}.
      * 
      * @see #getEnumSet(Class)
@@ -2081,6 +2195,19 @@
     }
 
     /**
+     * Reads a long sized bit vector and converts it to an {@link EnumSet}.
+     * 
+     * @see #getEnumSet(Class)
+     * @param <E>  the enum type
+     * @param index  the index from which the bytes will be read
+     * @param enumClass  the enum class used to create the EnumSet
+     * @return the EnumSet representation of the bit vector
+     */
+    public <E extends Enum<E>> EnumSet<E> getEnumSetLong(int index, Class<E> enumClass) {
+        return toEnumSet(enumClass, getLong(index));
+    }
+
+    /**
      * Utility method for converting a bit vector to an EnumSet. 
      */
     private <E extends Enum<E>> EnumSet<E> toEnumSet(Class<E> clazz, long vector) {
@@ -2106,8 +2233,22 @@
         if ((vector & ~BYTE_MASK) != 0) {
             throw new IllegalArgumentException("The enum set is too large to fit in a byte: " + set);
         }
-        put((byte) vector);
-        return this;
+        return put((byte) vector);
+    }
+
+    /**
+     * Writes the specified {@link EnumSet} to the buffer as a byte sized bit vector. 
+     * 
+     * @param <E> the enum type of the EnumSet
+     * @param index  the index at which the byte will be written
+     * @param set  the enum set to write to the buffer
+     */
+    public <E extends Enum<E>> ByteBuffer putEnumSet(int index, EnumSet<E> set) {
+        long vector = toLong(set);
+        if ((vector & ~BYTE_MASK) != 0) {
+            throw new IllegalArgumentException("The enum set is too large to fit in a byte: " + set);
+        }
+        return put(index, (byte) vector);
     }
 
     /**
@@ -2121,8 +2262,22 @@
         if ((vector & ~SHORT_MASK) != 0) {
             throw new IllegalArgumentException("The enum set is too large to fit in a short: " + set);
         }
-        putShort((short) vector);
-        return this;
+        return putShort((short) vector);
+    }
+
+    /**
+     * Writes the specified {@link EnumSet} to the buffer as a short sized bit vector. 
+     * 
+     * @param <E> the enum type of the EnumSet
+     * @param index  the index at which the bytes will be written
+     * @param set  the enum set to write to the buffer
+     */
+    public <E extends Enum<E>> ByteBuffer putEnumSetShort(int index, EnumSet<E> set) {
+        long vector = toLong(set);
+        if ((vector & ~SHORT_MASK) != 0) {
+            throw new IllegalArgumentException("The enum set is too large to fit in a short: " + set);
+        }
+        return putShort(index, (short) vector);
     }
 
     /**
@@ -2136,8 +2291,22 @@
         if ((vector & ~INT_MASK) != 0) {
             throw new IllegalArgumentException("The enum set is too large to fit in an int: " + set);
         }
-        putInt((int) vector);
-        return this;
+        return putInt((int) vector);
+    }
+
+    /**
+     * Writes the specified {@link EnumSet} to the buffer as an int sized bit vector. 
+     * 
+     * @param <E> the enum type of the EnumSet
+     * @param index  the index at which the bytes will be written
+     * @param set  the enum set to write to the buffer
+     */
+    public <E extends Enum<E>> ByteBuffer putEnumSetInt(int index, EnumSet<E> set) {
+        long vector = toLong(set);
+        if ((vector & ~INT_MASK) != 0) {
+            throw new IllegalArgumentException("The enum set is too large to fit in an int: " + set);
+        }
+        return putInt(index, (int) vector);
     }
 
     /**
@@ -2147,8 +2316,18 @@
      * @param set  the enum set to write to the buffer
      */
     public <E extends Enum<E>> ByteBuffer putEnumSetLong(EnumSet<E> set) {
-        putLong(toLong(set));
-        return this;
+        return putLong(toLong(set));
+    }
+
+    /**
+     * Writes the specified {@link EnumSet} to the buffer as a long sized bit vector. 
+     * 
+     * @param <E> the enum type of the EnumSet
+     * @param index  the index at which the bytes will be written
+     * @param set  the enum set to write to the buffer
+     */
+    public <E extends Enum<E>> ByteBuffer putEnumSetLong(int index, EnumSet<E> set) {
+        return putLong(index, toLong(set));
     }
 
     /**