Add int key compare method to (Direct|Byte)BufferProxy

lmdbjava · at055612 · Mar 6, 2025 · Mar 6, 2025 · Mar 6, 2025 · Mar 6, 2025
commit 4fd89fff1755e1572929da3097809dfdad5fa1bb
diff --git a/src/main/java/org/lmdbjava/AbstractFlagSet.java b/src/main/java/org/lmdbjava/AbstractFlagSet.java
@@ -64,7 +64,6 @@ public boolean isSet(final T flag) {
     // Probably cheaper to compare the masks than to use EnumSet.contains()
     return flag != null
         && MaskedFlag.isSet(mask, flag);
-
   }
 
   /**
@@ -93,9 +92,7 @@ public Iterator<T> iterator() {
 
   @Override
   public boolean equals(Object object) {
-    if (this == object) return true;
-//    if (object == null || getClass() != object.getClass()) return false;
-    return FlagSet.equals(this, (FlagSet<?>) object);
+    return FlagSet.equals(this, object);
   }
 
   @Override
@@ -141,6 +138,15 @@ public boolean isSet(final T flag) {
       return this.flag == flag;
     }
 
+    @Override
+    public boolean areAnySet(FlagSet<T> flags) {
+      if (flags == null) {
+        return false;
+      } else {
+        return flags.isSet(this.flag);
+      }
+    }
+
     @Override
     public int size() {
       return 1;
@@ -167,9 +173,7 @@ public String toString() {
 
     @Override
     public boolean equals(Object object) {
-      if (this == object) return true;
-//      if (object == null || getClass() != object.getClass()) return false;
-      return FlagSet.equals(this, (FlagSet<?>) object);
+      return FlagSet.equals(this, object);
     }
 
     @Override
@@ -205,6 +209,11 @@ public boolean isSet(final T flag) {
       return false;
     }
 
+    @Override
+    public boolean areAnySet(final FlagSet<T> flags) {
+      return false;
+    }
+
     @Override
     public int size() {
       return 0;
@@ -227,9 +236,7 @@ public String toString() {
 
     @Override
     public boolean equals(Object object) {
-      if (this == object) return true;
-//      if (object == null || getClass() != object.getClass()) return false;
-      return FlagSet.equals(this, (FlagSet<?>) object);
+      return FlagSet.equals(this, object);
     }
 
     @Override

diff --git a/src/main/java/org/lmdbjava/BufferProxy.java b/src/main/java/org/lmdbjava/BufferProxy.java
@@ -40,6 +40,11 @@ public abstract class BufferProxy<T> {
   /** Offset from a pointer of the <code>MDB_val.mv_size</code> field. */
   protected static final int STRUCT_FIELD_OFFSET_SIZE = 0;
 
+  /** The set of {@link DbiFlags} that indicate unsigned integer keys are being used. */
+  protected static final DbiFlagSet INTEGER_KEY_FLAGS = DbiFlagSet.of(
+      DbiFlags.MDB_INTEGERKEY,
+      DbiFlags.MDB_INTEGERDUP);
+
   /** Explicitly-defined default constructor to avoid warnings. */
   protected BufferProxy() {}
 
@@ -88,28 +93,6 @@ public Comparator<T> getComparator() {
     return getComparator(DbiFlagSet.empty());
   }
 
-//  /**
-//   * Get a suitable default {@link Comparator} to compare numeric key values as signed.
-//   *
-//   * <p>Note: LMDB's default comparator is unsigned so if this is used only for the {@link
-//   * CursorIterable} start/stop key comparisons then its behaviour will differ from the iteration
-//   * order. Use with caution.
-//   *
-//   * @return a comparator that can be used (never null)
-//   */
-//  public abstract Comparator<T> getSignedComparator();
-//
-//  /**
-//   * Get a suitable default {@link Comparator} to compare numeric key values as unsigned.
-//   * <p>
-//   * This should match the behaviour of the LMDB's mdb_cmp comparator as it may be used for
-//   * {@link CursorIterable} start/stop keys comparisons, which must match LMDB's insertion order.
-//   * </p>
-//   *
-//   * @return a comparator that can be used (never null)
-//   */
-//  public abstract Comparator<T> getUnsignedComparator(final DbiFlagSet dbiFlagSet);
-
   /**
    * Called when the <code>MDB_val</code> should be set to reflect the passed buffer. This buffer
    * will have been created by end users, not {@link #allocate()}.

diff --git a/src/main/java/org/lmdbjava/ByteArrayProxy.java b/src/main/java/org/lmdbjava/ByteArrayProxy.java
@@ -36,7 +36,6 @@ public final class ByteArrayProxy extends BufferProxy<byte[]> {
 
   private static final MemoryManager MEM_MGR = RUNTIME.getMemoryManager();
 
-  private static final Comparator<byte[]> signedComparator = ByteArrayProxy::compareArraysSigned;
   private static final Comparator<byte[]> unsignedComparator = ByteArrayProxy::compareArrays;
 
   private ByteArrayProxy() {}
@@ -68,26 +67,6 @@ public static int compareArrays(final byte[] o1, final byte[] o2) {
     return o1.length - o2.length;
   }
 
-  /**
-   * Compare two byte arrays.
-   *
-   * @param b1 left operand (required)
-   * @param b2 right operand (required)
-   * @return as specified by {@link Comparable} interface
-   */
-  public static int compareArraysSigned(final byte[] b1, final byte[] b2) {
-    requireNonNull(b1);
-    requireNonNull(b2);
-
-    if (b1 == b2) return 0;
-
-    for (int i = 0; i < min(b1.length, b2.length); ++i) {
-      if (b1[i] != b2[i]) return b1[i] - b2[i];
-    }
-
-    return b1.length - b2.length;
-  }
-
   @Override
   protected byte[] allocate() {
     return new byte[0];
@@ -108,16 +87,6 @@ public Comparator<byte[]> getComparator(final DbiFlagSet dbiFlagSet) {
     return unsignedComparator;
   }
 
-  //  @Override
-//  public Comparator<byte[]> getSignedComparator() {
-//    return signedComparator;
-//  }
-//
-//  @Override
-//  public Comparator<byte[]> getUnsignedComparator() {
-//    return unsignedComparator;
-//  }
-
   @Override
   protected Pointer in(final byte[] buffer, final Pointer ptr) {
     final Pointer pointer = MEM_MGR.allocateDirect(buffer.length);

diff --git a/src/main/java/org/lmdbjava/ByteBufProxy.java b/src/main/java/org/lmdbjava/ByteBufProxy.java
@@ -118,16 +118,6 @@ public Comparator<ByteBuf> getComparator(final DbiFlagSet dbiFlagSet) {
     return comparator;
   }
 
-  //  @Override
-//  public Comparator<ByteBuf> getSignedComparator() {
-//    return comparator;
-//  }
-//
-//  @Override
-//  public Comparator<ByteBuf> getUnsignedComparator() {
-//    return comparator;
-//  }
-
   @Override
   protected void deallocate(final ByteBuf buff) {
     buff.release();

diff --git a/src/main/java/org/lmdbjava/ByteBufferProxy.java b/src/main/java/org/lmdbjava/ByteBufferProxy.java
@@ -54,15 +54,19 @@ public final class ByteBufferProxy {
    */
   public static final BufferProxy<ByteBuffer> PROXY_OPTIMAL;
 
-  /** The safe, reflective {@link ByteBuffer} proxy for this system. Guaranteed to never be null. */
+  /**
+   * The safe, reflective {@link ByteBuffer} proxy for this system. Guaranteed to never be null.
+   */
   public static final BufferProxy<ByteBuffer> PROXY_SAFE;
 
+
   static {
     PROXY_SAFE = new ReflectiveProxy();
     PROXY_OPTIMAL = getProxyOptimal();
   }
 
-  private ByteBufferProxy() {}
+  private ByteBufferProxy() {
+  }
 
   private static BufferProxy<ByteBuffer> getProxyOptimal() {
     try {
@@ -72,17 +76,25 @@ private static BufferProxy<ByteBuffer> getProxyOptimal() {
     }
   }
 
-  /** The buffer must be a direct buffer (not heap allocated). */
+  /**
+   * The buffer must be a direct buffer (not heap allocated).
+   */
   public static final class BufferMustBeDirectException extends LmdbException {
 
     private static final long serialVersionUID = 1L;
 
-    /** Creates a new instance. */
+    /**
+     * Creates a new instance.
+     */
     public BufferMustBeDirectException() {
       super("The buffer must be a direct buffer (not heap allocated");
     }
   }
 
+
+  // --------------------------------------------------------------------------------
+
+
   /**
    * Provides {@link ByteBuffer} pooling and address resolution for concrete {@link BufferProxy}
    * implementations.
@@ -92,16 +104,6 @@ abstract static class AbstractByteBufferProxy extends BufferProxy<ByteBuffer> {
     protected static final String FIELD_NAME_ADDRESS = "address";
     protected static final String FIELD_NAME_CAPACITY = "capacity";
 
-    private static final Comparator<ByteBuffer> signedComparator =
-        (o1, o2) -> {
-          requireNonNull(o1);
-          requireNonNull(o2);
-
-          return o1.compareTo(o2);
-        };
-    private static final Comparator<ByteBuffer> unsignedComparator =
-        AbstractByteBufferProxy::compareBuff;
-
     /**
      * A thread-safe pool for a given length. If the buffer found is valid (ie not of a negative
      * length) then that buffer is used. If no valid buffer is found, a new buffer is created.
@@ -116,7 +118,7 @@ abstract static class AbstractByteBufferProxy extends BufferProxy<ByteBuffer> {
      * @param o2 right operand (required)
      * @return as specified by {@link Comparable} interface
      */
-    public static int compareBuff(final ByteBuffer o1, final ByteBuffer o2) {
+    public static int compareLexicographically(final ByteBuffer o1, final ByteBuffer o2) {
       requireNonNull(o1);
       requireNonNull(o2);
       if (o1.equals(o2)) {
@@ -148,34 +150,42 @@ public static int compareBuff(final ByteBuffer o1, final ByteBuffer o2) {
       return o1.remaining() - o2.remaining();
     }
 
-//    /**
-//     * Possible compareBuff method specifically for 4/8 byte keys when using MDB_INTEGER_KEY
-//     */
-//    public static int compareBuff(final ByteBuffer o1, final ByteBuffer o2) {
-//      requireNonNull(o1);
-//      requireNonNull(o2);
-//      // Both buffers should be same len
-//      final int len1 = o1.limit();
-//      final int len2 = o2.limit();
-//      if (len1 != len2) {
-//        throw new RuntimeException("Length mismatch, len1: " + len1 + ", len2: " + len2
-//            + ". Lengths must be identical and either 4 or 8 bytes.");
-//      }
-//      final boolean reverse1 = o1.order() == LITTLE_ENDIAN;
-//      final boolean reverse2 = o2.order() == LITTLE_ENDIAN;
-//      if (len1 == 8) {
-//          final long lw = reverse1 ? Long.reverseBytes(o1.getLong()) : o1.getLong();
-//          final long rw = reverse2 ? Long.reverseBytes(o2.getLong()) : o2.getLong();
-//          return Long.compareUnsigned(lw, rw);
-//      } else if (len1 == 4) {
-//        final int lw = reverse1 ? Integer.reverseBytes(o1.getInt()) : o1.getInt();
-//        final int rw = reverse2 ? Integer.reverseBytes(o2.getInt()) : o2.getInt();
-//          return Integer.compareUnsigned(lw, rw);
-//      } else {
-//        throw new RuntimeException("Unexpected length len1: " + len1 + ", len2: " + len2
-//            + ". Lengths must be identical and either 4 or 8 bytes.");
-//      }
-//    }
+    /**
+     * Buffer comparator specifically for 4/8 byte keys that are unsigned ints/longs,
+     * i.e. when using MDB_INTEGER_KEY/MDB_INTEGERDUP. Compares the buffers numerically.
+     * <p>
+     * Both buffer must have 4 or 8 bytes remaining
+     * </p>
+     *
+     * @param o1 left operand (required)
+     * @param o2 right operand (required)
+     * @return as specified by {@link Comparable} interface
+     */
+    public static int compareAsIntegerKeys(final ByteBuffer o1, final ByteBuffer o2) {
+      requireNonNull(o1);
+      requireNonNull(o2);
+      // Both buffers should be same len
+      final int len1 = o1.limit();
+      final int len2 = o2.limit();
+      if (len1 != len2) {
+        throw new RuntimeException("Length mismatch, len1: " + len1 + ", len2: " + len2
+            + ". Lengths must be identical and either 4 or 8 bytes.");
+      }
+      final boolean reverse1 = o1.order() == LITTLE_ENDIAN;
+      final boolean reverse2 = o2.order() == LITTLE_ENDIAN;
+      if (len1 == 8) {
+        final long lw = reverse1 ? Long.reverseBytes(o1.getLong(0)) : o1.getLong(0);
+        final long rw = reverse2 ? Long.reverseBytes(o2.getLong(0)) : o2.getLong(0);
+        return Long.compareUnsigned(lw, rw);
+      } else if (len1 == 4) {
+        final int lw = reverse1 ? Integer.reverseBytes(o1.getInt(0)) : o1.getInt(0);
+        final int rw = reverse2 ? Integer.reverseBytes(o2.getInt(0)) : o2.getInt(0);
+        return Integer.compareUnsigned(lw, rw);
+      } else {
+        throw new RuntimeException("Unexpected length1: " + len1
+            + ". Lengths must be identical and either 4 or 8 bytes.");
+      }
+    }
 
     static Field findField(final Class<?> c, final String name) {
       Class<?> clazz = c;
@@ -211,20 +221,14 @@ protected final ByteBuffer allocate() {
     }
 
     @Override
-    public Comparator<ByteBuffer> getComparator(DbiFlagSet dbiFlagSet) {
-      return unsignedComparator;
+    public Comparator<ByteBuffer> getComparator(final DbiFlagSet dbiFlagSet) {
+      if (dbiFlagSet.areAnySet(INTEGER_KEY_FLAGS)) {
+        return AbstractByteBufferProxy::compareAsIntegerKeys;
+      } else {
+        return AbstractByteBufferProxy::compareLexicographically;
+      }
     }
 
-    //    @Override
-//    public Comparator<ByteBuffer> getSignedComparator() {
-//      return signedComparator;
-//    }
-//
-//    @Override
-//    public Comparator<ByteBuffer> getUnsignedComparator(final DbiFlagSet dbiFlagSet) {
-//      return unsignedComparator;
-//    }
-
     @Override
     protected final void deallocate(final ByteBuffer buff) {
       buff.order(BIG_ENDIAN);
@@ -240,6 +244,10 @@ protected byte[] getBytes(final ByteBuffer buffer) {
     }
   }
 
+
+  // --------------------------------------------------------------------------------
+
+
   /**
    * A proxy that uses Java reflection to modify byte buffer fields, and official JNR-FFF methods to
    * manipulate native pointers.
@@ -284,6 +292,10 @@ protected ByteBuffer out(final ByteBuffer buffer, final Pointer ptr) {
     }
   }
 
+
+  // --------------------------------------------------------------------------------
+
+
   /**
    * A proxy that uses Java's "unsafe" class to directly manipulate byte buffer fields and JNR-FFF
    * allocated memory pointers.