Buffers float/double conversion: Add arg for given destination buffer; Add back conversion; Add unit test for arrays

3 files changed, 241 insertions, 8 deletions

diff --git a/make/scripts/runtest.sh b/make/scripts/runtest.sh
index 4a1fea3..b494397 100644
--- a/make/scripts/runtest.sh
+++ b/make/scripts/runtest.sh
@@ -38,11 +38,12 @@ function onetest() {
     echo
 }
 
-onetest com.jogamp.common.GlueGenVersion 2>&1 | tee -a $LOG
+#onetest com.jogamp.common.GlueGenVersion 2>&1 | tee -a $LOG
 #onetest com.jogamp.common.util.TestVersionInfo 2>&1 | tee -a $LOG
 #onetest com.jogamp.common.util.TestIteratorIndexCORE 2>&1 | tee -a $LOG
 #onetest com.jogamp.common.util.locks.TestRecursiveLock01 2>&1 | tee -a $LOG
 #onetest com.jogamp.common.util.TestArrayHashSet01 2>&1 | tee -a $LOG
+onetest com.jogamp.common.nio.TestBuffersFloatDoubleConversion 2>&1 | tee -a $LOG
 #onetest com.jogamp.gluegen.PCPPTest 2>&1 | tee -a $LOG
 #onetest com.jogamp.gluegen.test.TestPointerBufferEndian 2>&1 | tee -a $LOG
 #onetest com.jogamp.gluegen.test.TestStructAccessorEndian 2>&1 | tee -a $LOG
diff --git a/src/java/com/jogamp/common/nio/Buffers.java b/src/java/com/jogamp/common/nio/Buffers.java
index 7e5f8eb..a1ea320 100755
--- a/src/java/com/jogamp/common/nio/Buffers.java
+++ b/src/java/com/jogamp/common/nio/Buffers.java
@@ -544,22 +544,101 @@ public class Buffers {
     // Conversion routines
     //
 
-    public static float[] getFloatArray(double[] source) {
-        int i=source.length;
-        float[] dest = new float[i--];
-        while(i>=0) { dest[i]=(float)source[i]; i--; }
+    /**
+     * @param source the source array
+     * @param soffset the offset
+     * @param dest the target array, if null, a new array is being created with size len.
+     * @param doffset the offset in the dest array
+     * @param len the payload of elements to be copied, if <code>len < 0</code> then <code>len = source.length - soffset</code>
+     * @return the passed or newly created target array
+     */
+    public static float[] getFloatArray(double[] source, int soffset, float[] dest, int doffset, int len) {
+        if(0>len) {
+            len = source.length - soffset;
+        }
+        if(len > source.length - soffset) {
+            throw new IllegalArgumentException("payload ("+len+") greater than remaining source bytes [len "+source.length+", offset "+soffset+"]");
+        }
+        if(null==dest) {
+            dest = new float[len];
+            doffset = 0;
+        }
+        if(len > dest.length - doffset) {
+            throw new IllegalArgumentException("payload ("+len+") greater than remaining dest bytes [len "+dest.length+", offset "+doffset+"]");
+        }
+        for(int i=0; i<len; i++) {
+            dest[doffset+i] = (float) source[soffset+i];
+        }
         return dest;
     }
 
-    public final static FloatBuffer getFloatBuffer(DoubleBuffer source) {
-        source.rewind();
-        FloatBuffer dest = newDirectFloatBuffer(source.limit());
+    /**
+     * No rewind or repositioning is performed.
+     * @param source the source buffer, which elements from it's current position and it's limit are being copied
+     * @param dest the target buffer, if null, a new buffer is being created with size </code>source.remaining()</code>
+     * @return the passed or newly created target buffer
+     */
+    public static FloatBuffer getFloatBuffer(DoubleBuffer source, FloatBuffer dest) {
+        if(null == dest) {
+            dest = newDirectFloatBuffer(source.remaining());
+        }
+        if( dest.remaining() < source.remaining() ) {
+            throw new IllegalArgumentException("payload ("+source.remaining()+") is greater than remaining dest bytes: "+dest.remaining());
+        }
         while (source.hasRemaining()) {
             dest.put((float) source.get());
         }
         return dest;
     }
 
+    /**
+     * @param source the source array
+     * @param soffset the offset
+     * @param dest the target array, if null, a new array is being created with size len.
+     * @param doffset the offset in the dest array
+     * @param len the payload of elements to be copied, if <code>len < 0</code> then <code>len = source.length - soffset</code>
+     * @return the passed or newly created target array
+     */
+    public static double[] getDoubleArray(float[] source, int soffset, double[] dest, int doffset, int len) {
+        if(0>len) {
+            len = source.length - soffset;
+        }
+        if(len > source.length - soffset) {
+            throw new IllegalArgumentException("payload ("+len+") greater than remaining source bytes [len "+source.length+", offset "+soffset+"]");
+        }
+        if(null==dest) {
+            dest = new double[len];
+            doffset = 0;
+        }
+        if(len > dest.length - doffset) {
+            throw new IllegalArgumentException("payload ("+len+") greater than remaining dest bytes [len "+dest.length+", offset "+doffset+"]");
+        }
+        for(int i=0; i<len; i++) {
+            dest[doffset+i] = (double) source[soffset+i];
+        }
+        return dest;
+    }
+
+    /**
+     * No rewind or repositioning is performed.
+     * @param source the source buffer, which elements from it's current position and it's limit are being copied
+     * @param dest the target buffer, if null, a new buffer is being created with size </code>source.remaining()</code>
+     * @return the passed or newly created target buffer
+     */
+    public static DoubleBuffer getDoubleBuffer(FloatBuffer source, DoubleBuffer dest) {
+        if(null == dest) {
+            dest = newDirectDoubleBuffer(source.remaining());
+        }
+        if( dest.remaining() < source.remaining() ) {
+            throw new IllegalArgumentException("payload ("+source.remaining()+") is greater than remaining dest bytes: "+dest.remaining());
+        }
+        while (source.hasRemaining()) {
+            dest.put((double) source.get());
+        }
+        return dest;
+    }
+
+
     //----------------------------------------------------------------------
     // Convenient put methods with generic target Buffer
     //
diff --git a/src/junit/com/jogamp/common/nio/TestBuffersFloatDoubleConversion.java b/src/junit/com/jogamp/common/nio/TestBuffersFloatDoubleConversion.java
new file mode 100644
index 0000000..0555578
--- /dev/null
+++ b/src/junit/com/jogamp/common/nio/TestBuffersFloatDoubleConversion.java
@@ -0,0 +1,153 @@
+/**
+ * Copyright 2010 JogAmp Community. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without modification, are
+ * permitted provided that the following conditions are met:
+ * 
+ *    1. Redistributions of source code must retain the above copyright notice, this list of
+ *       conditions and the following disclaimer.
+ * 
+ *    2. Redistributions in binary form must reproduce the above copyright notice, this list
+ *       of conditions and the following disclaimer in the documentation and/or other materials
+ *       provided with the distribution.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY JogAmp Community ``AS IS'' AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
+ * FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL JogAmp Community OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 
+ * The views and conclusions contained in the software and documentation are those of the
+ * authors and should not be interpreted as representing official policies, either expressed
+ * or implied, of JogAmp Community.
+ */
+ 
+package com.jogamp.common.nio;
+
+import java.io.IOException;
+import org.junit.Assert;
+
+import org.junit.Test;
+
+public class TestBuffersFloatDoubleConversion {
+
+    public static boolean cmpFloatArray(float[] d1, int d1_offset, float[] d2, int d2_offset, int len) {
+        if( d1.length - d1_offset < len) {
+            throw new RuntimeException("d1 too small len "+len+" > "+d1.length+" - "+d1_offset);
+        }
+        if( d2.length - d2_offset < len) {
+            throw new RuntimeException("d2 too small len "+len+" > "+d2.length+" - "+d2_offset);
+        }
+        boolean ok = true;
+        for(int i=0; ok && i<len; i++) {
+            ok = d1[d1_offset+i] == d2[d2_offset+i] ;
+        }
+        return ok;
+    }
+
+    public static boolean cmpDoubleArray(double[] d1, int d1_offset, double[] d2, int d2_offset, int len) {
+        if( d1.length - d1_offset < len) {
+            throw new RuntimeException("d1 too small len "+len+" > "+d1.length+" - "+d1_offset);
+        }
+        if( d2.length - d2_offset < len) {
+            throw new RuntimeException("d2 too small len "+len+" > "+d2.length+" - "+d2_offset);
+        }
+        boolean ok = true;
+        for(int i=0; ok && i<len; i++) {
+            ok = d1[d1_offset+i] == d2[d2_offset+i] ;
+        }
+        return ok;
+    }
+
+    public static void incrFloatArray(float[] data, int offset, int len) {
+        if( data.length - offset < len) {
+            throw new RuntimeException("data too small len "+len+" > "+data.length+" - "+offset);
+        }
+        for(int i=0; i<len; i++) {
+            data[offset+i] += 1;
+        }
+    }
+
+    public static void incrDoubleArray(double[] data, int offset, int len) {
+        if( data.length - offset < len) {
+            throw new RuntimeException("data too small len "+len+" > "+data.length+" - "+offset);
+        }
+        for(int i=0; i<len; i++) {
+            data[offset+i] += 1;
+        }
+    }
+
+    public static void setFloatArray(float[] data, int offset, int len) {
+        if( data.length - offset < len) {
+            throw new RuntimeException("data too small len "+len+" > "+data.length+" - "+offset);
+        }
+        for(int i=0; i<len; i++) {
+            data[offset+i] = i;
+        }
+    }
+
+    public static void setDoubleArray(double[] data, int offset, int len) {
+        if( data.length - offset < len) {
+            throw new RuntimeException("data too small len "+len+" > "+data.length+" - "+offset);
+        }
+        for(int i=0; i<len; i++) {
+            data[offset+i] = i;
+        }
+    }
+
+    public static void doItDoubleArray01(double[] data, int offset, int len) {
+        float[] f_data = Buffers.getFloatArray(data, offset, null, 0, len);
+        incrFloatArray(f_data, 0, len);
+        Buffers.getDoubleArray(f_data, 0, data, offset, len);
+    }
+
+    @Test
+    public void testDoubleArray2FloatArrayAndBack01() {
+        final int offset = 50;
+        final int len = 20;
+
+        // reference 1
+        float[] fa_ref = new float[100];
+        setFloatArray(fa_ref, offset, len);
+        incrFloatArray(fa_ref, offset, len);
+
+        // reference 2
+        double[] da_ref = new double[100];
+        setDoubleArray(da_ref, offset, len);
+        incrDoubleArray(da_ref, offset, len);
+
+        // test 1: forth and back .. double -> float -> double
+        {
+            double[] da1 = new double[100];
+            setDoubleArray(da1, offset, len);
+            incrDoubleArray(da1, offset, len);
+
+            // conv_forth: double[offset..len] -> float[0..len]
+            float[] f_da1 = Buffers.getFloatArray(da1, offset, null, 0, len);
+            Assert.assertTrue(cmpFloatArray(fa_ref, offset, f_da1, 0, len));
+
+            // conv_back: float[0..len] -> double[offset..len]
+            Buffers.getDoubleArray(f_da1, 0, da1, offset, len);
+            Assert.assertTrue(cmpDoubleArray(da_ref, offset, da1, offset, len));
+        }
+
+        // test 2: forth, incr, back .. double -> float -> incr -> double
+        {
+            double[] da1 = new double[100];
+            setDoubleArray(da1, offset, len);
+
+            doItDoubleArray01(da1, offset, len);
+            Assert.assertTrue(cmpDoubleArray(da_ref, offset, da1, offset, len));
+        }
+    }
+
+    public static void main(String args[]) throws IOException {
+        String tstname = TestBuffersFloatDoubleConversion.class.getName();
+        org.junit.runner.JUnitCore.main(tstname);
+    }
+
+}