added reverse decoding to LIbae

6jkruege · 6jkruege · commit d3f8f20b35e4 · 2021-03-13T14:14:00.000+01:00
diff --git a/src/jokrey/utilities/encoder/as_union/li/LIPosition.java b/src/jokrey/utilities/encoder/as_union/li/LIPosition.java
@@ -3,6 +3,8 @@
 import jokrey.utilities.encoder.as_union.Position;
 import jokrey.utilities.transparent_storage.TransparentStorage;
 
+import java.util.Objects;
+
 /**
  * @author jokrey
  */
@@ -15,7 +17,23 @@ public LIPosition(long pointer) {
         return pointer < storage.contentSize();
     }
 
-    @Override public String toString() {
-        return "LIPosition{pointer=" + pointer + '}';
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+        LIPosition that = (LIPosition) o;
+        return pointer == that.pointer;
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(pointer);
+    }
+
+    @Override
+    public String toString() {
+        return "LIPosition{" +
+                "pointer=" + pointer +
+                '}';
     }
 }
diff --git a/src/jokrey/utilities/encoder/as_union/li/ReverseLIPosition.java b/src/jokrey/utilities/encoder/as_union/li/ReverseLIPosition.java
@@ -0,0 +1,42 @@
+package jokrey.utilities.encoder.as_union.li;
+
+import jokrey.utilities.encoder.as_union.Position;
+import jokrey.utilities.transparent_storage.TransparentStorage;
+
+import java.util.Objects;
+
+/**
+ * @author jokrey
+ */
+public class ReverseLIPosition extends Position {
+    public final long minimum;
+    public long pointer;
+    public ReverseLIPosition(long pointer, long minimum) {
+        this.pointer = pointer;
+        this.minimum = minimum;
+    }
+    @Override public boolean hasNext(TransparentStorage storage) {
+        return pointer > minimum;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+        ReverseLIPosition that = (ReverseLIPosition) o;
+        return minimum == that.minimum && pointer == that.pointer;
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(minimum, pointer);
+    }
+
+    @Override
+    public String toString() {
+        return "ReverseLIPosition{" +
+                "minimum=" + minimum +
+                ", pointer=" + pointer +
+                '}';
+    }
+}
diff --git a/src/jokrey/utilities/encoder/as_union/li/bytes/LIbae.java b/src/jokrey/utilities/encoder/as_union/li/bytes/LIbae.java
@@ -4,6 +4,7 @@
 import jokrey.utilities.encoder.EncodableAsBytes;
 import jokrey.utilities.encoder.as_union.li.LIPosition;
 import jokrey.utilities.encoder.as_union.li.LIe;
+import jokrey.utilities.encoder.as_union.li.ReverseLIPosition;
 import jokrey.utilities.transparent_storage.StorageSystemException;
 import jokrey.utilities.transparent_storage.TransparentStorage;
 import jokrey.utilities.transparent_storage.bytes.TransparentBytesStorage;
@@ -263,20 +264,29 @@ public static long getIntFromByteArray(byte[] bytearr, int from, int len) {
 //        }
 //    }
 
+    protected long[] get_next_reverse_li_bounds(ReverseLIPosition start_pos, TransparentStorage<byte[]> contentBuilder) throws StorageSystemException {
+        long i = start_pos.pointer;
+        if(i-1 <= 0)
+            return null;
+        byte[] cache = contentBuilder.sub(i-9, i); //cache maximum number of required bytes. (to minimize possibly slow sub calls)
+
+        return get_next_reverse_li_bounds(cache, 0, i, start_pos.minimum);
+    }
+
     /**
      * @param partialData all or partial data
      * @param partialDataOffset offset in the partial data
      * @param li_offset latest index in the data
-     * @param totalDataSize last index of total data(+1) of which partial data is a part of
+     * @param minimum first index of total data of which partial data is a part of (usually 0, or header-offset)
      * @return Length indicated indices. The range between those indices is the encoded, connected data.
      */
-    public static long[] get_next_reverse_li_bounds(byte[] partialData, int partialDataOffset, long li_offset, long totalDataSize) {
+    public static long[] get_next_reverse_li_bounds(byte[] partialData, int partialDataOffset, long li_offset, long minimum) {
         if(partialDataOffset < 0) return null;
 
         byte leading_li = partialData[partialDataOffset];
 
         long lengthIndicator_asInt = getIntFromByteArray(partialData,  partialDataOffset-leading_li, leading_li);
-        if(lengthIndicator_asInt==-1 || li_offset+lengthIndicator_asInt>totalDataSize)
+        if(lengthIndicator_asInt==-1 || li_offset-lengthIndicator_asInt < minimum)
             return null;
         li_offset-=leading_li + 1; //to skip the li information.
         return new long[]{li_offset - lengthIndicator_asInt, li_offset};
@@ -296,4 +306,28 @@ public static byte[] generateReverseLI(long length) {
             li_bytes[n] = BitHelper.getByte(length, (li_bytes.length-2)-n);
         return li_bytes;
     }
+
+    public long reverseSkipEntry(ReverseLIPosition pos) {
+        long[] startIndex_endIndex_ofNextLI = get_next_reverse_li_bounds(pos, getStorageSystem());
+        if(startIndex_endIndex_ofNextLI != null) {
+            pos.pointer = startIndex_endIndex_ofNextLI[1];
+            return startIndex_endIndex_ofNextLI[1] - startIndex_endIndex_ofNextLI[0];
+        }
+        return -1;
+    }
+
+    public byte[] reverseDecode(ReverseLIPosition pos, boolean delete_decoded) {
+        long[] startIndex_endIndex_ofNextLI = get_next_reverse_li_bounds(pos, getStorageSystem());
+        if(startIndex_endIndex_ofNextLI != null) {
+            byte[] decoded = getStorageSystem().sub(startIndex_endIndex_ofNextLI[0], startIndex_endIndex_ofNextLI[1]);
+            if(delete_decoded) {
+                getStorageSystem().delete(startIndex_endIndex_ofNextLI[0], pos.pointer);
+            } else {
+                pos.pointer = startIndex_endIndex_ofNextLI[0];
+            }
+            return decoded;
+        } else {
+            return null;
+        }
+    }
 }
