Author: ruschein
Date: 2010-02-02 08:40:30 -0800 (Tue, 02 Feb 2010)
New Revision: 19118

Modified:
   
csplugins/trunk/util.compression/src/org/cytoscape/util/compression/IntCompressor.java
   
csplugins/trunk/util.compression/src/org/cytoscape/util/compression/RLEIntCompressor.java
Log:
First feature-complete implementation.

Modified: 
csplugins/trunk/util.compression/src/org/cytoscape/util/compression/IntCompressor.java
===================================================================
--- 
csplugins/trunk/util.compression/src/org/cytoscape/util/compression/IntCompressor.java
      2010-02-02 16:18:45 UTC (rev 19117)
+++ 
csplugins/trunk/util.compression/src/org/cytoscape/util/compression/IntCompressor.java
      2010-02-02 16:40:30 UTC (rev 19118)
@@ -3,5 +3,5 @@
 
 interface IntCompressor {
        int[] compress(final int[] uncompressedData);
-       int[] expand(final int[] compressedData);
+       int[] expand(final int[] compressedData) throws IllegalStateException;
 }

Modified: 
csplugins/trunk/util.compression/src/org/cytoscape/util/compression/RLEIntCompressor.java
===================================================================
--- 
csplugins/trunk/util.compression/src/org/cytoscape/util/compression/RLEIntCompressor.java
   2010-02-02 16:18:45 UTC (rev 19117)
+++ 
csplugins/trunk/util.compression/src/org/cytoscape/util/compression/RLEIntCompressor.java
   2010-02-02 16:40:30 UTC (rev 19118)
@@ -1,11 +1,18 @@
 package org.cytoscape.util.compression;
 
 
+/**
+ * Class to maintain a dynamically growing int array.
+ */
 class DynamicIntArray {
        private static final int DEFAULT_INITIAL_CAPACITY = 1000;
        private int[] array;
        private int nextIndex = 0;
 
+       DynamicIntArray() {
+               this(0);
+       }
+
        DynamicIntArray(final int initialCapacity) {
                if (initialCapacity > 0)
                        array = new int[initialCapacity];
@@ -20,6 +27,20 @@
                array[nextIndex++] = newValue;
        }
 
+       /**
+        * @return An array of the exact size of the data.
+        */
+       int[] toArray() {
+               final int[] retval = new int[nextIndex];
+               System.arraycopy(array, 0, retval, 0, nextIndex);
+
+               return retval;
+       }
+
+       /**
+        * Used to grow our internal array.  This is done by capacity doubling 
which implies that the
+        * amortised asymptotic complexity of append() is O(1) which is the 
best we can hope for!
+        */
        private void resize() {
                final int[] newArray = new int[array.length << 1];
                System.arraycopy(array, 0, newArray, 0, array.length);
@@ -28,10 +49,58 @@
 }
 
 
+/**
+ * Class that implements run-length encoding of int arrays.
+ */
 public class RLEIntCompressor {
        public int[] compress(final int[] uncompressedData) {
+               int runLength = 0;
+               int currentValue = uncompressedData[0];
+
+               final DynamicIntArray dynArray = new 
DynamicIntArray(uncompressedData.length);
+
+               for (final int value : uncompressedData) {
+                       if (value == currentValue) {
+                               ++runLength;
+                               if (runLength == Integer.MAX_VALUE) { // Yes, I 
am *that* paranoid!  ;)
+                                       dynArray.append(runLength);
+                                       dynArray.append(currentValue);
+                                       runLength = 0;
+                               }
+                       }
+                       else {
+                               dynArray.append(runLength);
+                               dynArray.append(currentValue);
+                               runLength = 1;
+                               currentValue = value;
+                       }
+               }
+
+               // Unfinished business?
+               if (runLength > 0) {
+                       dynArray.append(runLength);
+                       dynArray.append(currentValue);
+               }
+
+               return dynArray.toArray();
        }
 
-       public int[] expand(final int[] compressedData) {
+       public int[] expand(final int[] compressedData) throws 
IllegalStateException {
+               final DynamicIntArray dynArray = new 
DynamicIntArray(compressedData.length << 2);
+
+               try {
+                       int i = 0;
+                       while (i < compressedData.length) {
+                               final int runLength = compressedData[i++];
+                               final int value =  compressedData[i++];
+
+                               for (int k = 0; k < runLength; ++k)
+                                       dynArray.append(value);
+                       }
+               } catch (final ArrayIndexOutOfBoundsException e) {
+                       throw new IllegalStateException("garbled compressed 
data!");
+               }
+
+               return dynArray.toArray();
        }
 }

-- 
You received this message because you are subscribed to the Google Groups 
"cytoscape-cvs" group.
To post to this group, send email to [email protected].
To unsubscribe from this group, send email to 
[email protected].
For more options, visit this group at 
http://groups.google.com/group/cytoscape-cvs?hl=en.

Reply via email to