working java,python, js then added rust, then rewired java to j

src/main/java/com/reliancy/dbo/Ordering.java

@@ -0,0 +1,216 @@
+package com.reliancy.dbo;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * Ordering specification for multiple fields.
+ * 
+ * <p>This class manages an ordered list of field/direction pairs for sorting.
+ * It supports chaining methods to build complex ordering specifications.
+ * 
+ * <p>Example usage:
+ * <pre>{@code
+ * Ordering ordering = new Ordering("name ASC, created DESC", entity)
+ *     .orderBy(Field.by("status"))
+ *     .orderBy(Field.by("priority"), false);
+ * }</pre>
+ */
+public class Ordering {
+    private static class FieldOrder {
+        Field field;
+        boolean ascending;
+        
+        FieldOrder(Field field, boolean ascending) {
+            this.field = field;
+            this.ascending = ascending;
+        }
+    }
+    
+    private ArrayList<FieldOrder> orders = new ArrayList<>();
+    
+    /**
+     * Creates an empty Ordering.
+     */
+    public Ordering() {
+    }
+    
+    /**
+     * Creates an Ordering from a string specification.
+     * 
+     * @param str String in format "field1 ASC, field2 DESC, ..." or "field1, field2, ..."
+     * @param entity Entity to resolve field names
+     */
+    public Ordering(String str, Entity entity) {
+        fromString(str, entity);
+    }
+    
+    /**
+     * Creates an Ordering with a single field.
+     * 
+     * @param field Field to order by
+     * @param ascending true for ascending, false for descending
+     */
+    public Ordering(Field field, boolean ascending) {
+        orderBy(field, ascending);
+    }
+    
+    /**
+     * Parses a string specification and adds to this ordering.
+     * 
+     * @param str String in format "field1 ASC, field2 DESC, ..." or "field1, field2, ..."
+     * @param entity Entity to resolve field names
+     * @return this for chaining
+     */
+    public Ordering fromString(String str, Entity entity) {
+        if (str == null || str.trim().isEmpty()) {
+            return this;
+        }
+        String[] parts = str.split(",");
+        for (String part : parts) {
+            part = part.trim();
+            if (part.isEmpty()) continue;
+            if (!part.contains(" ")) part = part + " ASC";
+            String[] fieldParts = part.split("\\s+");
+            Field field = entity.getField(fieldParts[0]);
+            if (field == null) {
+                throw new IllegalArgumentException("Field " + fieldParts[0] + " not found in entity " + entity.getName());
+            }
+            boolean ascending = fieldParts.length > 1 && fieldParts[1].equalsIgnoreCase("ASC");
+            orderBy(field, ascending);
+        }
+        return this;
+    }
+    
+    /**
+     * Clears all ordering specifications.
+     * 
+     * @return this for chaining
+     */
+    public Ordering clear() {
+        orders.clear();
+        return this;
+    }
+    
+    /**
+     * Adds a field to order by (ascending by default).
+     * 
+     * @param field Field to order by
+     * @return this for chaining
+     */
+    public Ordering orderBy(Field field) {
+        return orderBy(field, true);
+    }
+    
+    /**
+     * Adds a field to order by with specified direction.
+     * 
+     * @param field Field to order by
+     * @param ascending true for ascending, false for descending
+     * @return this for chaining
+     */
+    public Ordering orderBy(Field field, boolean ascending) {
+        if (field != null) {
+            orders.add(new FieldOrder(field, ascending));
+        }
+        return this;
+    }
+    
+    /**
+     * Gets the number of ordering specifications.
+     * 
+     * @return number of fields in this ordering
+     */
+    public int size() {
+        return orders.size();
+    }
+    
+    /**
+     * Gets the field at the specified index.
+     * 
+     * @param index index of the field
+     * @return Field at the index
+     */
+    public Field getField(int index) {
+        return orders.get(index).field;
+    }
+    
+    /**
+     * Gets whether the field at the specified index is ascending.
+     * 
+     * @param index index of the field
+     * @return true if ascending, false if descending
+     */
+    public boolean isAscending(int index) {
+        return orders.get(index).ascending;
+    }
+    
+    /**
+     * Gets all fields in this ordering.
+     * 
+     * @return list of fields
+     */
+    public List<Field> getFields() {
+        List<Field> fields = new ArrayList<>();
+        for (FieldOrder fo : orders) {
+            fields.add(fo.field);
+        }
+        return fields;
+    }
+    
+    /**
+     * Checks if this ordering is empty.
+     * 
+     * @return true if no fields are specified
+     */
+    public boolean isEmpty() {
+        return orders.isEmpty();
+    }
+    
+    @Override
+    public String toString() {
+        if (orders.isEmpty()) {
+            return "";
+        }
+        StringBuilder sb = new StringBuilder();
+        for (int i = 0; i < orders.size(); i++) {
+            if (i > 0) sb.append(", ");
+            FieldOrder fo = orders.get(i);
+            sb.append(fo.field.getName()).append(fo.ascending ? " ASC" : " DESC");
+        }
+        return sb.toString();
+    }
+    
+    // Static factory methods for backward compatibility and convenience
+    
+    /**
+     * Creates an Ordering with a single ascending field.
+     * 
+     * @param field Field to order by
+     * @return new Ordering instance
+     */
+    public static Ordering ascending(Field field) {
+        return new Ordering(field, true);
+    }
+    
+    /**
+     * Creates an Ordering with a single descending field.
+     * 
+     * @param field Field to order by
+     * @return new Ordering instance
+     */
+    public static Ordering descending(Field field) {
+        return new Ordering(field, false);
+    }
+    
+    /**
+     * Creates an Ordering with a single ascending field.
+     * 
+     * @param field Field to order by
+     * @return new Ordering instance
+     */
+    public static Ordering by(Field field) {
+        return new Ordering(field, true);
+    }
+    
+}