Rename SEGMENT_SIZE and reorder methods

Rename SEGMENT_SIZE constant to ENTRY_SIZE for clarity
in NativeSegmentList. Reorder methods alphabetically:
move close() and ensureCapacity() before add() to match
the project's member-ordering convention.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: mtopolnik

core/src/main/java/io/questdb/client/cutlass/qwp/client/NativeSegmentList.java

@@ -28,7 +28,7 @@
 import io.questdb.client.std.Unsafe;
 
 final class NativeSegmentList implements QuietCloseable {
-    static final int SEGMENT_SIZE = 16;
+    static final int ENTRY_SIZE = 16;
 
     private int capacity;
     private long ptr;
@@ -41,15 +41,49 @@ final class NativeSegmentList implements QuietCloseable {
 
     NativeSegmentList(int initialCapacity) {
         this.capacity = Math.max(initialCapacity, 4);
-        this.ptr = Unsafe.malloc((long) capacity * SEGMENT_SIZE, MemoryTag.NATIVE_DEFAULT);
+        this.ptr = Unsafe.malloc((long) capacity * ENTRY_SIZE, MemoryTag.NATIVE_DEFAULT);
+    }
+
+    @Override
+    public void close() {
+        if (ptr != 0) {
+            Unsafe.free(ptr, (long) capacity * ENTRY_SIZE, MemoryTag.NATIVE_DEFAULT);
+            ptr = 0;
+            capacity = 0;
+            size = 0;
+            totalLength = 0;
+        }
+    }
+
+    private void ensureCapacity(int required) {
+        if (required <= capacity) {
+            return;
+        }
+
+        int newCapacity = capacity;
+        while (newCapacity < required) {
+            if (newCapacity > Integer.MAX_VALUE / 2) {
+                newCapacity = required;
+                break;
+            }
+            newCapacity *= 2;
+        }
+
+        ptr = Unsafe.realloc(
+                ptr,
+                (long) capacity * ENTRY_SIZE,
+                (long) newCapacity * ENTRY_SIZE,
+                MemoryTag.NATIVE_DEFAULT
+        );
+        capacity = newCapacity;
     }
 
     void add(long address, long length) {
         if (length <= 0) {
             return;
         }
         ensureCapacity(size + 1);
-        long segmentPtr = ptr + (long) size * SEGMENT_SIZE;
+        long segmentPtr = ptr + (long) size * ENTRY_SIZE;
         Unsafe.getUnsafe().putLong(segmentPtr, address);
         Unsafe.getUnsafe().putLong(segmentPtr + 8, length);
         size++;
@@ -63,8 +97,8 @@ void appendFrom(NativeSegmentList other) {
         ensureCapacity(size + other.size);
         Unsafe.getUnsafe().copyMemory(
                 other.ptr,
-                ptr + (long) size * SEGMENT_SIZE,
-                (long) other.size * SEGMENT_SIZE
+                ptr + (long) size * ENTRY_SIZE,
+                (long) other.size * ENTRY_SIZE
         );
         size += other.size;
         totalLength += other.totalLength;
@@ -82,42 +116,8 @@ long getTotalLength() {
         return totalLength;
     }
 
-    @Override
-    public void close() {
-        if (ptr != 0) {
-            Unsafe.free(ptr, (long) capacity * SEGMENT_SIZE, MemoryTag.NATIVE_DEFAULT);
-            ptr = 0;
-            capacity = 0;
-            size = 0;
-            totalLength = 0;
-        }
-    }
-
     void reset() {
         size = 0;
         totalLength = 0;
     }
-
-    private void ensureCapacity(int required) {
-        if (required <= capacity) {
-            return;
-        }
-
-        int newCapacity = capacity;
-        while (newCapacity < required) {
-            if (newCapacity > Integer.MAX_VALUE / 2) {
-                newCapacity = required;
-                break;
-            }
-            newCapacity *= 2;
-        }
-
-        ptr = Unsafe.realloc(
-                ptr,
-                (long) capacity * SEGMENT_SIZE,
-                (long) newCapacity * SEGMENT_SIZE,
-                MemoryTag.NATIVE_DEFAULT
-        );
-        capacity = newCapacity;
-    }
 }