Woop works

src/main/java/com/volmit/iris/util/hunk/bits/DataContainer.java

@@ -30,8 +30,8 @@ import java.util.concurrent.atomic.AtomicInteger;
 import java.util.concurrent.atomic.AtomicReference;
 
 public class DataContainer<T> {
-    protected static final int INITIAL_BITS = 2;
-    protected static final int LINEAR_BITS_LIMIT = 5;
+    protected static final int INITIAL_BITS = 3;
+    protected static final int LINEAR_BITS_LIMIT = 4;
     protected static final int LINEAR_INITIAL_LENGTH = (int) Math.pow(2, LINEAR_BITS_LIMIT) + 1;
     protected static final int[] BIT = computeBitLimits();
     private final AtomicReference<Palette<T>> palette;
@@ -56,6 +56,51 @@ public class DataContainer<T> {
         this.bits = new AtomicInteger(palette.get().bits());
     }
 
+    public static String readBitString(DataInputStream din) throws IOException
+    {
+        DataContainer<Character> c = new DataContainer<>(din, new Writable<Character>() {
+            @Override
+            public Character readNodeData(DataInputStream din) throws IOException {
+                return din.readChar();
+            }
+
+            @Override
+            public void writeNodeData(DataOutputStream dos, Character character) throws IOException {
+                dos.writeChar(character);
+            }
+        });
+
+        StringBuilder sb = new StringBuilder();
+
+        for(int i = c.size()-1; i >= 0; i--)
+        {
+            sb.setCharAt(i, c.get(i));
+        }
+
+        return sb.toString();
+    }
+
+    public static void writeBitString(String s, DataOutputStream dos) throws IOException {
+        DataContainer<Character> c = new DataContainer<>(new Writable<Character>() {
+            @Override
+            public Character readNodeData(DataInputStream din) throws IOException {
+                return din.readChar();
+            }
+
+            @Override
+            public void writeNodeData(DataOutputStream dos, Character character) throws IOException {
+                dos.writeChar(character);
+            }
+        }, s.length());
+
+        for(int i = 0; i < s.length(); i++)
+        {
+            c.set(i, s.charAt(i));
+        }
+
+        c.writeDos(dos);
+    }
+
     public DataBits getData()
     {
         return data.get();
@@ -125,7 +170,7 @@ public class DataContainer<T> {
     }
 
     private void expandOne() {
-        if (palette.get().size() + 1 >= BIT[bits.get()] - 1) {
+        if (palette.get().size() + 1 >= BIT[bits.get()]) {
             setBits(bits.get() + 1);
         }
     }

src/main/java/com/volmit/iris/util/hunk/bits/TecTest.java

@@ -18,10 +18,93 @@
 
 package com.volmit.iris.util.hunk.bits;
 
+import com.volmit.iris.Iris;
+import com.volmit.iris.util.collection.KList;
+import com.volmit.iris.util.collection.KSet;
+import com.volmit.iris.util.format.Form;
+import com.volmit.iris.util.io.IO;
+import com.volmit.iris.util.math.RNG;
+import com.volmit.iris.util.matter.slices.BlockMatter;
+import org.bukkit.Material;
+import org.bukkit.block.data.BlockData;
+
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.DataInputStream;
+import java.io.DataOutputStream;
+import java.io.IOException;
+import java.nio.charset.StandardCharsets;
+import java.util.Arrays;
+import java.util.Set;
+
 public class TecTest {
+    public static Set<BlockData> randomBlocks(int max)
+    {
+        KSet<BlockData> d = new KSet<>();
+
+        while(d.size() < max)
+        {
+            Material m = Material.values()[RNG.r.i(Material.values().length - 1)];
+            if(m.isBlock())
+            {
+                d.add(m.createBlockData());
+            }
+        }
+
+        return d;
+    }
+
     public static void go()
     {
 
+    }
 
+    public static boolean test(int size, int pal)
+    {
+        try
+        {
+            Iris.info("Test? " + size + " " + pal);
+            KList<BlockData> blocks = new KList<>(randomBlocks(pal));
+            Iris.info("Fill " + pal + " -> " + size + " Entries");
+            Writable<BlockData> writer = new BlockMatter();
+            DataContainer<BlockData> dc = new DataContainer<>(writer, size);
+
+            for(int i = 0; i < dc.size(); i++)
+            {
+                dc.set(i, blocks.getRandom());
+            }
+
+            Iris.info(dc.toString());
+            byte[] dat = dc.write();
+            DataContainer<BlockData> dx = new DataContainer<>(new DataInputStream(new ByteArrayInputStream(dat)), writer);
+            Iris.info(dx.toString());
+            byte[] dat2 = dx.write();
+            Iris.info("Size: " + Form.memSize(dat.length, 2) + " -> " + Form.memSize(dat2.length, 2));
+
+            if(Arrays.equals(dat, dat2)) {
+                Iris.info("MATCH");
+                return true;
+            }
+            else
+            {
+                for(int i = 0; i < dc.size(); i++)
+                {
+                    if(!dx.get(i).equals(dc.get(i)))
+                    {
+                        Iris.info("FAIL Expected " + dc.get(i).getAsString(true) + " but got " + dx.get(i).getAsString(true));
+                        return false;
+                    }
+                }
+                Iris.info("MATCH but different output?");
+
+                return true;
+            }
+        }
+
+        catch(Throwable e)
+        {
+            e.printStackTrace();
+            return false;
+        }
     }
 }