Add support to wrap primitives via ChannelBuffers.wrap*(..) easily. See

#167

buffer/src/main/java/io/netty/buffer/ChannelBuffers.java

@@ -821,6 +821,81 @@ public final class ChannelBuffers {
         return new ReadOnlyChannelBuffer(buffer);
     }
 
+    /**
+     * Create a {@link ChannelBuffer} that holds all the given values as int's
+     * 
+     */
+    public static ChannelBuffer wrapInt(int... values) {
+        if (values == null || values.length == 0) {
+            return EMPTY_BUFFER;
+        }
+        ChannelBuffer buffer = buffer(values.length * 4);
+        for (int v: values) {
+            buffer.writeInt(v);
+        }
+        return buffer;
+    }
+    
+    /**
+     * Create a {@link ChannelBuffer} that holds all the given values as short's
+     * 
+     */
+    public static ChannelBuffer wrapShort(int... values) {
+        if (values == null || values.length == 0) {
+            return EMPTY_BUFFER;
+        }
+        ChannelBuffer buffer = buffer(values.length * 2);
+        for (int v: values) {
+            buffer.writeShort(v);
+        }
+        return buffer;
+    }
+    
+    /**
+     * Create a {@link ChannelBuffer} that holds all the given values as medium's
+     * 
+     */
+    public static ChannelBuffer wrapMedium(int... values) {
+        if (values == null || values.length == 0) {
+            return EMPTY_BUFFER;
+        }
+        ChannelBuffer buffer = buffer(values.length * 3);
+        for (int v: values) {
+            buffer.writeMedium(v);
+        }
+        return buffer;
+    }
+    
+    /**
+     * Create a {@link ChannelBuffer} that holds all the given values as long's
+     * 
+     */
+    public static ChannelBuffer wrapLong(long... values) {
+        if (values == null || values.length == 0) {
+            return EMPTY_BUFFER;
+        }
+        ChannelBuffer buffer = buffer(values.length * 8);
+        for (long v: values) {
+            buffer.writeLong(v);
+        }
+        return buffer;
+    }
+    
+    /**
+     * Create a {@link ChannelBuffer} that holds all the given values as boolean's
+     * 
+     */
+    public static ChannelBuffer wrapBoolean(boolean... values) {
+        if (values == null || values.length == 0) {
+            return EMPTY_BUFFER;
+        }
+        ChannelBuffer buffer = buffer(values.length);
+        for (boolean v: values) {
+            buffer.writeBoolean(v);
+        }
+        return buffer;
+    }    
+    
     /**
      * Returns a <a href="http://en.wikipedia.org/wiki/Hex_dump">hex dump</a>
      * of the specified buffer's readable bytes.

buffer/src/test/java/io/netty/buffer/ChannelBuffersTest.java

@@ -425,4 +425,70 @@ public class ChannelBuffersTest {
             // Expected
         }
     }
+    
+    @Test
+    public void testWrapInt() {
+        ChannelBuffer buffer = ChannelBuffers.wrapInt(1,4);
+        assertEquals(8, buffer.capacity());
+        assertEquals(1, buffer.readInt());
+        assertEquals(4, buffer.readInt());
+        assertFalse(buffer.readable());
+        
+        assertEquals(0, ChannelBuffers.wrapInt(null).capacity());
+        assertEquals(0, ChannelBuffers.wrapInt(new int[0]).capacity());
+
+    }
+    
+    @Test
+    public void testWrapShort() {
+        ChannelBuffer buffer = ChannelBuffers.wrapShort(1,4);
+        assertEquals(4, buffer.capacity());
+        assertEquals(1, buffer.readShort());
+        assertEquals(4, buffer.readShort());
+        assertFalse(buffer.readable());
+        
+        assertEquals(0, ChannelBuffers.wrapShort(null).capacity());
+        assertEquals(0, ChannelBuffers.wrapShort(new int[0]).capacity());
+
+    }
+    
+    @Test
+    public void testWrapMedium() {
+        ChannelBuffer buffer = ChannelBuffers.wrapMedium(1,4);
+        assertEquals(6, buffer.capacity());
+        assertEquals(1, buffer.readMedium());
+        assertEquals(4, buffer.readMedium());
+        assertFalse(buffer.readable());
+        
+        assertEquals(0, ChannelBuffers.wrapMedium(null).capacity());
+        assertEquals(0, ChannelBuffers.wrapMedium(new int[0]).capacity());
+
+    }
+    
+    
+    @Test
+    public void testWrapLong() {
+        ChannelBuffer buffer = ChannelBuffers.wrapLong(1,4);
+        assertEquals(16, buffer.capacity());
+        assertEquals(1, buffer.readLong());
+        assertEquals(4, buffer.readLong());
+        assertFalse(buffer.readable());
+        
+        assertEquals(0, ChannelBuffers.wrapLong(null).capacity());
+        assertEquals(0, ChannelBuffers.wrapLong(new long[0]).capacity());
+
+    }
+    
+    @Test
+    public void testWrapBoolean() {
+        ChannelBuffer buffer = ChannelBuffers.wrapBoolean(true, false);
+        assertEquals(2, buffer.capacity());
+        assertEquals(true, buffer.readBoolean());
+        assertEquals(false, buffer.readBoolean());
+        assertFalse(buffer.readable());
+        
+        assertEquals(0, ChannelBuffers.wrapBoolean(null).capacity());
+        assertEquals(0, ChannelBuffers.wrapBoolean(new boolean[0]).capacity());
+
+    }
 }