Merge remote branch 'mbien/master'

5 files changed, 87 insertions, 54 deletions

diff --git a/nbproject/project.xml b/nbproject/project.xml
index 81ca39e..654f87f 100755
--- a/nbproject/project.xml
+++ b/nbproject/project.xml
@@ -135,7 +135,7 @@
                 </action>
                 <action name="test">
                     <script>${ant.script}</script>
-                    <target>test</target>
+                    <target>junit.run</target>
                 </action>
                 <action name="run.single">
                     <script>nbproject/ide-file-targets.xml</script>
diff --git a/src/java/com/jogamp/common/nio/Buffers.java b/src/java/com/jogamp/common/nio/Buffers.java
index 9b7db23..2a1ab18 100755
--- a/src/java/com/jogamp/common/nio/Buffers.java
+++ b/src/java/com/jogamp/common/nio/Buffers.java
@@ -41,11 +41,13 @@ package com.jogamp.common.nio;
 import java.nio.*;
 
 /**
+ * Utility methods allowing easy {@link java.nio.Buffer} manipulations.
+ * 
  * @author Kenneth Russel
  * @author Sven Gothel
  * @author Michael Bien
  */
-public class Buffers {
+public final class Buffers {
 
     public static final int SIZEOF_BYTE     = 1;
     public static final int SIZEOF_SHORT    = 2;
@@ -55,7 +57,7 @@ public class Buffers {
     public static final int SIZEOF_LONG     = 8;
     public static final int SIZEOF_DOUBLE   = 8;
 
-    protected Buffers() {}
+    private Buffers() {}
 
     /**
      * Allocates a new direct ByteBuffer with the specified number of
@@ -205,38 +207,45 @@ public class Buffers {
     }
 
     /**
-     * Calls slice on the concrete buffer type.
+     * Calls slice on the specified buffer.
+     * @see #slice(java.nio.Buffer, int, int) 
      */
-    public static Buffer slice(Buffer buffer) {
+    public static <B extends Buffer> B slice(B buffer) {
         if (buffer instanceof ByteBuffer) {
-            return ((ByteBuffer) buffer).slice();
+            return (B) ((ByteBuffer) buffer).slice();
         } else if (buffer instanceof IntBuffer) {
-            return ((IntBuffer) buffer).slice();
+            return (B) ((IntBuffer) buffer).slice();
         } else if (buffer instanceof ShortBuffer) {
-            return ((ShortBuffer) buffer).slice();
+            return (B) ((ShortBuffer) buffer).slice();
         } else if (buffer instanceof FloatBuffer) {
-            return ((FloatBuffer) buffer).slice();
+            return (B) ((FloatBuffer) buffer).slice();
         } else if (buffer instanceof DoubleBuffer) {
-            return ((DoubleBuffer) buffer).slice();
+            return (B) ((DoubleBuffer) buffer).slice();
         } else if (buffer instanceof LongBuffer) {
-            return ((LongBuffer) buffer).slice();
+            return (B) ((LongBuffer) buffer).slice();
         } else if (buffer instanceof CharBuffer) {
-            return ((CharBuffer) buffer).slice();
+            return (B) ((CharBuffer) buffer).slice();
         }
         throw new IllegalArgumentException("unexpected buffer type: " + buffer.getClass());
     }
 
     /**
      * Slices the specified buffer with offset as position and offset+size as limit.
+     * Concurrency warning: this method changes the buffers position and limit but
+     * will restore it before return.
      */
-    public static Buffer slice(Buffer buffer, int offset, int size) {
+    public static <B extends Buffer> B slice(B buffer, int offset, int size) {
         int pos = buffer.position();
         int limit = buffer.limit();
 
-        buffer.position(offset).limit(offset+size);
-        Buffer slice = slice(buffer);
+        B slice = null;
+        try{
+            buffer.position(offset).limit(offset+size);
+            slice = slice(buffer);
+        }finally{
+            buffer.position(pos).limit(limit);
+        }
 
-        buffer.position(pos).limit(limit);
         return slice;
     }
 
@@ -623,69 +632,69 @@ public class Buffers {
     //----------------------------------------------------------------------
     // Convenient put methods with generic target Buffer
     //
-    public static Buffer put(Buffer dest, Buffer src) {
+    public static <B extends Buffer> B put(B dest, Buffer src) {
         if ((dest instanceof ByteBuffer) && (src instanceof ByteBuffer)) {
-            return ((ByteBuffer) dest).put((ByteBuffer) src);
+            return (B) ((ByteBuffer) dest).put((ByteBuffer) src);
         } else if ((dest instanceof ShortBuffer) && (src instanceof ShortBuffer)) {
-            return ((ShortBuffer) dest).put((ShortBuffer) src);
+            return (B) ((ShortBuffer) dest).put((ShortBuffer) src);
         } else if ((dest instanceof IntBuffer) && (src instanceof IntBuffer)) {
-            return ((IntBuffer) dest).put((IntBuffer) src);
+            return (B) ((IntBuffer) dest).put((IntBuffer) src);
         } else if ((dest instanceof FloatBuffer) && (src instanceof FloatBuffer)) {
-            return ((FloatBuffer) dest).put((FloatBuffer) src);
+            return (B) ((FloatBuffer) dest).put((FloatBuffer) src);
         } else if ((dest instanceof LongBuffer) && (src instanceof LongBuffer)) {
-            return ((LongBuffer) dest).put((LongBuffer) src);
+            return (B) ((LongBuffer) dest).put((LongBuffer) src);
         } else if ((dest instanceof DoubleBuffer) && (src instanceof DoubleBuffer)) {
-            return ((DoubleBuffer) dest).put((DoubleBuffer) src);
+            return (B) ((DoubleBuffer) dest).put((DoubleBuffer) src);
         } else if ((dest instanceof CharBuffer) && (src instanceof CharBuffer)) {
-            return ((CharBuffer) dest).put((CharBuffer) src);
+            return (B) ((CharBuffer) dest).put((CharBuffer) src);
         }
         throw new IllegalArgumentException("Incompatible Buffer classes: dest = " + dest.getClass().getName() + ", src = " + src.getClass().getName());
     }
 
-    public static Buffer putb(Buffer dest, byte v) {
+    public static <B extends Buffer> B putb(B dest, byte v) {
         if (dest instanceof ByteBuffer) {
-            return ((ByteBuffer) dest).put(v);
+            return (B) ((ByteBuffer) dest).put(v);
         } else if (dest instanceof ShortBuffer) {
-            return ((ShortBuffer) dest).put((short) v);
+            return (B) ((ShortBuffer) dest).put((short) v);
         } else if (dest instanceof IntBuffer) {
-            return ((IntBuffer) dest).put((int) v);
+            return (B) ((IntBuffer) dest).put((int) v);
         } else {
             throw new IllegalArgumentException("Byte doesn't match Buffer Class: " + dest);
         }
     }
 
-    public static Buffer puts(Buffer dest, short v) {
+    public static <B extends Buffer> B puts(B dest, short v) {
         if (dest instanceof ShortBuffer) {
-            return ((ShortBuffer) dest).put(v);
+            return (B) ((ShortBuffer) dest).put(v);
         } else if (dest instanceof IntBuffer) {
-            return ((IntBuffer) dest).put((int) v);
+            return (B) ((IntBuffer) dest).put((int) v);
         } else {
             throw new IllegalArgumentException("Short doesn't match Buffer Class: " + dest);
         }
     }
 
-    public static void puti(Buffer dest, int v) {
+    public static <B extends Buffer> B puti(B dest, int v) {
         if (dest instanceof IntBuffer) {
-            ((IntBuffer) dest).put(v);
+            return (B) ((IntBuffer) dest).put(v);
         } else {
             throw new IllegalArgumentException("Integer doesn't match Buffer Class: " + dest);
         }
     }
 
-    public static void putf(Buffer dest, float v) {
+    public static <B extends Buffer> B putf(B dest, float v) {
         if (dest instanceof FloatBuffer) {
-            ((FloatBuffer) dest).put(v);
+            return (B) ((FloatBuffer) dest).put(v);
 /* TODO FixedPoint required
         } else if (dest instanceof IntBuffer) {
-            ((IntBuffer) dest).put(FixedPoint.toFixed(v));
+            return (B) ((IntBuffer) dest).put(FixedPoint.toFixed(v));
 */
         } else {
             throw new IllegalArgumentException("Float doesn't match Buffer Class: " + dest);
         }
     }
-    public static void putd(Buffer dest, double v) {
+    public static <B extends Buffer> B putd(B dest, double v) {
         if (dest instanceof FloatBuffer) {
-            ((FloatBuffer) dest).put((float) v);
+            return (B) ((FloatBuffer) dest).put((float) v);
         } else {
             throw new IllegalArgumentException("Double doesn't match Buffer Class: " + dest);
         }
diff --git a/src/junit/com/jogamp/common/nio/BuffersTest.java b/src/junit/com/jogamp/common/nio/BuffersTest.java
index 0b72cd4..836e46d 100644
--- a/src/junit/com/jogamp/common/nio/BuffersTest.java
+++ b/src/junit/com/jogamp/common/nio/BuffersTest.java
@@ -43,14 +43,45 @@ public class BuffersTest {
 
     @Test
     public void slice() {
+        
         IntBuffer buffer = Buffers.newDirectIntBuffer(6);
         buffer.put(new int[]{1,2,3,4,5,6}).rewind();
 
-        IntBuffer threefour = (IntBuffer)Buffers.slice(buffer, 2, 2);
+        IntBuffer threefour = Buffers.slice(buffer, 2, 2);
 
         assertEquals(3, threefour.get(0));
         assertEquals(4, threefour.get(1));
         assertEquals(2, threefour.capacity());
+        
+        assertEquals(0, buffer.position());
+        assertEquals(6, buffer.limit());
+
+        IntBuffer fourfivesix = Buffers.slice(buffer, 3, 3);
+
+        assertEquals(4, fourfivesix.get(0));
+        assertEquals(5, fourfivesix.get(1));
+        assertEquals(6, fourfivesix.get(2));
+        assertEquals(3, fourfivesix.capacity());
+        
+        assertEquals(0, buffer.position());
+        assertEquals(6, buffer.limit());
+        
+        IntBuffer onetwothree = Buffers.slice(buffer, 0, 3);
+
+        assertEquals(1, onetwothree.get(0));
+        assertEquals(2, onetwothree.get(1));
+        assertEquals(3, onetwothree.get(2));
+        assertEquals(3, onetwothree.capacity());
+        
+        assertEquals(0, buffer.position());
+        assertEquals(6, buffer.limit());
+        
+        // is it really sliced?
+        buffer.put(2, 42);
+        
+        assertEquals(42, buffer.get(2));
+        assertEquals(42, onetwothree.get(2));
+        
 
     }
 
diff --git a/src/junit/com/jogamp/gluegen/test/junit/runtime/TestPointerBufferEndian.java b/src/junit/com/jogamp/common/nio/TestPointerBufferEndian.java
index afe3405..da232a2 100644
--- a/src/junit/com/jogamp/gluegen/test/junit/runtime/TestPointerBufferEndian.java
+++ b/src/junit/com/jogamp/common/nio/TestPointerBufferEndian.java
@@ -1,14 +1,9 @@
 
-package com.jogamp.gluegen.test.junit.runtime;
+package com.jogamp.common.nio;
 
-import com.jogamp.common.nio.*;
 import com.jogamp.common.os.*;
 
-import java.nio.*;
-
 import org.junit.Assert;
-import org.junit.Before;
-import org.junit.BeforeClass;
 import org.junit.Test;
 
 import static java.lang.System.*;
@@ -20,9 +15,9 @@ public class TestPointerBufferEndian {
         String bitsProp = System.getProperty("sun.arch.data.model");
         String os = System.getProperty("os.name");
         String cpu = System.getProperty("os.arch");
-        System.out.println("OS: <"+os+"> CPU: <"+cpu+"> Bits: <"+bitsPtr+"/"+bitsProp+">");
-        System.out.println("CPU is: "+ (Platform.is32Bit()?"32":"64") + " bit");
-        System.out.println("Buffer is in: "+ (Platform.isLittleEndian()?"little":"big") + " endian");
+        out.println("OS: <"+os+"> CPU: <"+cpu+"> Bits: <"+bitsPtr+"/"+bitsProp+">");
+        out.println("CPU is: "+ (Platform.is32Bit()?"32":"64") + " bit");
+        out.println("Buffer is in: "+ (Platform.isLittleEndian()?"little":"big") + " endian");
 
         long[] valuesSource = { 0x0123456789ABCDEFL, 0x8877665544332211L, 0xAFFEDEADBEEFAFFEL };
         long[] values32Bit  = { 0x0000000089ABCDEFL, 0x0000000044332211L, 0x00000000BEEFAFFEL };
diff --git a/src/junit/com/jogamp/gluegen/test/junit/runtime/TestStructAccessorEndian.java b/src/junit/com/jogamp/common/nio/TestStructAccessorEndian.java
index 264c86b..09781ec 100644
--- a/src/junit/com/jogamp/gluegen/test/junit/runtime/TestStructAccessorEndian.java
+++ b/src/junit/com/jogamp/common/nio/TestStructAccessorEndian.java
@@ -1,4 +1,4 @@
-package com.jogamp.gluegen.test.junit.runtime;
+package com.jogamp.common.nio;
 
 import com.jogamp.common.nio.*;
 import com.jogamp.common.os.*;
@@ -6,8 +6,6 @@ import com.jogamp.common.os.*;
 import java.nio.*;
 
 import org.junit.Assert;
-import org.junit.Before;
-import org.junit.BeforeClass;
 import org.junit.Test;
 
 import static java.lang.System.*;
@@ -20,9 +18,9 @@ public class TestStructAccessorEndian {
         String bitsProp = System.getProperty("sun.arch.data.model");
         String os = System.getProperty("os.name");
         String cpu = System.getProperty("os.arch");
-        System.out.println("OS: <"+os+"> CPU: <"+cpu+"> Bits: <"+bitsPtr+"/"+bitsProp+">");
-        System.out.println("CPU is: "+ (Platform.is32Bit()?"32":"64") + " bit");
-        System.out.println("Buffer is in: "+ (Platform.isLittleEndian()?"little":"big") + " endian");
+        out.println("OS: <"+os+"> CPU: <"+cpu+"> Bits: <"+bitsPtr+"/"+bitsProp+">");
+        out.println("CPU is: "+ (Platform.is32Bit()?"32":"64") + " bit");
+        out.println("Buffer is in: "+ (Platform.isLittleEndian()?"little":"big") + " endian");
 
         long[] valuesSource = { 0x0123456789ABCDEFL, 0x8877665544332211L, 0xAFFEDEADBEEFAFFEL };
         ByteBuffer tst = Buffers.newDirectByteBuffer(Buffers.SIZEOF_LONG * valuesSource.length);