rust-java: Add most of methods in TaffyTree

bindings/java/java/src/main/java/com/dioxuslabs/taffy/TaffyTree.java

@@ -4,45 +4,161 @@
 import com.dioxuslabs.taffy.geom.measure.TaffyAvailableSpace;
 import com.dioxuslabs.taffy.style.TaffyStyle;
 import com.dioxuslabs.taffy.tree.TaffyLayout;
+import com.sun.jdi.NativeMethodException;
 
 import java.util.List;
+import java.util.Optional;
 
 public class TaffyTree {
     public final long ptr;
 
     public TaffyTree() {
-        this.ptr = newTaffyTree();
+        this.ptr = nvNewTaffyTree();
+    }
+
+    public TaffyTree(int capacity) {
+        this.ptr = nvNewTaffyTreeWithCapacity(capacity);
+    }
+
+    public void enableRounding() {
+        nvEnableRounding(this.ptr);
+    }
+
+    public void disableRounding() {
+        nvDisableRounding(this.ptr);
     }
 
     public long newLeaf(TaffyStyle style) {
-        return newLeaf(this.ptr, style);
+        return nvNewLeaf(this.ptr, style);
     }
 
     public long newWithChildren(TaffyStyle style, List<Long> children) {
-        return newWithChildren(this.ptr, style, children);
+        return nvNewWithChildren(this.ptr, style, children);
     }
 
     public int childCount(long nodeId) {
-        return childCount(this.ptr, nodeId);
+        return nvChildCount(this.ptr, nodeId);
     }
 
-    public void computeLayout(long node, TaffySize<TaffyAvailableSpace> availableSize) {
-        computeLayout(this.ptr, node, availableSize);
+    public void clear() {
+        nvClear(this.ptr);
+    }
+
+    public long remove(long nodeId) {
+        return nvRemove(this.ptr, nodeId);
+    }
+
+    public void addChild(long parent, long child) {
+        nvAddChild(this.ptr, parent, child);
+    }
+
+    public void insertChildAtIndex(long parent, int childIndex, int child) {
+        nvInsertChildAtIndex(this.ptr, parent, childIndex, child);
+    }
+
+    public void setChildren(long parent, List<Long> children) {
+        nvSetChildren(this.ptr, parent, children);
+    }
+
+    public long removeChild(long parent, long child) {
+        return nvRemoveChild(this.ptr, parent, child);
+    }
+
+    public long removeChildAtIndex(long parent, int childIndex) {
+        return nvRemoveChildAtIndex(this.ptr, parent, childIndex);
+    }
+
+    public long replaceChildAtIndex(long parent, int childIndex, long newChild) {
+        return nvReplaceChildAtIndex(this.ptr, parent, childIndex, newChild);
+    }
+
+    public long childAtIndex(long parent, int childIndex) {
+        return nvChildAtIndex(this.ptr, parent, childIndex);
+    }
+
+    /**
+     * Returns the total number of nodes in the tree
+     */
+    public int totalNodeCount() {
+        return nvTotalNodeCount(this.ptr);
+    }
+
+    public Optional<Long> parent(long nodeId) {
+        throw new UnsupportedOperationException("Not implemented yet");
+    }
+
+    /**
+     * Returns a list of children that belong to the parent node
+     */
+    public List<Long> children(long nodeId) {
+        throw new UnsupportedOperationException("Not implemented yet");
+    }
+
+    public void setStyle(long node, TaffyStyle style) {
+        nvSetStyle(this.ptr, node, style);
+    }
+
+    public TaffyStyle style(long node) {
+        throw new UnsupportedOperationException("Not implemented yet");
     }
 
     public TaffyLayout layout(long node) {
-        return layout(this.ptr, node);
+        return nvLayout(this.ptr, node);
+    }
+
+    public void computeLayout(long node, TaffySize<TaffyAvailableSpace> availableSize) {
+        nvComputeLayout(this.ptr, node, availableSize);
+    }
+
+    public void printTree(long node) {
+        nvPrintTree(this.ptr, node);
     }
 
-    private static native long newTaffyTree();
+    private static native long nvNewTaffyTree();
+
+    private static native long nvNewTaffyTreeWithCapacity(int capacity);
+
+    private static native void nvEnableRounding(long pointer);
+
+    private static native void nvDisableRounding(long pointer);
+
+    private static native long nvNewLeaf(long pointer, TaffyStyle style);
+
+    private static native long nvNewWithChildren(long pointer, TaffyStyle style, List<Long> children);
+
+    private static native int nvChildCount(long pointer, long nodeId);
+
+    private static native void nvClear(long pointer);
+
+    private static native long nvRemove(long pointer, long node);
+
+    private static native void nvAddChild(long pointer, long parent, long child);
+
+    private static native void nvInsertChildAtIndex(long pointer, long parent, int childIndex, long child);
+
+    private static native void nvSetChildren(long pointer, long parent, List<Long> children);
+
+    private static native long nvRemoveChild(long pointer, long parent, long child);
+
+    private static native long nvRemoveChildAtIndex(long pointer, long parent, int childIndex);
+
+    private static native long nvReplaceChildAtIndex(long pointer, long parent, int childIndex, long newChild);
+
+    private static native long nvChildAtIndex(long pointer, long parent, int childIndex);
+
+    private static native int nvTotalNodeCount(long pointer);
+
+    private static native long nvParent(long pointer, long nodeId);
+
+    private static native List<Long> nvChildren(long pointer, long nodeId);
 
-    private static native long newLeaf(long pointer, TaffyStyle style);
+    private static native void nvSetStyle(long pointer, long node, TaffyStyle style);
 
-    private static native long newWithChildren(long pointer, TaffyStyle style, List<Long> children);
+    private static native TaffyStyle nvStyle(long pointer, long node);
 
-    private static native int childCount(long pointer, long nodeId);
+    private static native void nvComputeLayout(long pointer, long node, TaffySize<TaffyAvailableSpace> availableSize);
 
-    private static native void computeLayout(long pointer, long node, TaffySize<TaffyAvailableSpace> availableSize);
+    private static native void nvPrintTree(long pointer, long node);
 
-    private static native TaffyLayout layout(long pointer, long node);
+    private static native TaffyLayout nvLayout(long pointer, long node);
 }

bindings/java/src/lib.rs

@@ -19,17 +19,59 @@ use std::panic;
 use taffy::{NodeId, TaffyTree, TraversePartialTree};
 
 #[no_mangle]
-pub extern "system" fn Java_com_dioxuslabs_taffy_TaffyTree_newTaffyTree<'local>(
+pub extern "system" fn Java_com_dioxuslabs_taffy_TaffyTree_nvNewTaffyTree<'local>(
     _env: JNIEnv<'local>,
     _class: JClass<'local>,
 ) -> jlong {
     let tree: Box<TaffyTree<()>> = Box::new(TaffyTree::new());
     Box::into_raw(tree) as jlong
 }
 
+#[no_mangle]
+pub extern "system" fn Java_com_dioxuslabs_taffy_TaffyTree_nvNewTaffyTreeWithCapacity<'local>(
+    _env: JNIEnv<'local>,
+    _class: JClass<'local>,
+    capacity: jint,
+) -> jlong {
+    let tree: Box<TaffyTree<()>> = Box::new(TaffyTree::with_capacity(capacity as usize));
+    Box::into_raw(tree) as jlong
+}
+
+#[no_mangle]
+pub extern "system" fn Java_com_dioxuslabs_taffy_TaffyTree_nvEnableRounding<'local>(
+    _env: JNIEnv<'local>,
+    _class: JClass<'local>,
+    pointer: jlong,
+) {
+    unsafe {
+        let raw_ptr: *mut TaffyTree<()> = pointer as *mut TaffyTree<()>;
+        if raw_ptr.is_null() {
+            return;
+        }
+        let tree: &mut TaffyTree<()> = &mut *raw_ptr;
+        tree.enable_rounding()
+    }
+}
+
+#[no_mangle]
+pub extern "system" fn Java_com_dioxuslabs_taffy_TaffyTree_nvDisableRounding<'local>(
+    _env: JNIEnv<'local>,
+    _class: JClass<'local>,
+    pointer: jlong,
+) {
+    unsafe {
+        let raw_ptr: *mut TaffyTree<()> = pointer as *mut TaffyTree<()>;
+        if raw_ptr.is_null() {
+            return;
+        }
+        let tree: &mut TaffyTree<()> = &mut *raw_ptr;
+        tree.disable_rounding()
+    }
+}
+
 #[no_mangle]
 #[allow(clippy::not_unsafe_ptr_arg_deref)]
-pub extern "system" fn Java_com_dioxuslabs_taffy_TaffyTree_newLeaf<'local>(
+pub extern "system" fn Java_com_dioxuslabs_taffy_TaffyTree_nvNewLeaf<'local>(
     mut env: JNIEnv<'local>,
     _class: JClass<'local>,
     pointer: jlong,
@@ -39,9 +81,6 @@ pub extern "system" fn Java_com_dioxuslabs_taffy_TaffyTree_newLeaf<'local>(
         let style = get_style(&mut env, &JObject::from_raw(style));
 
         let raw_ptr: *mut TaffyTree<()> = pointer as *mut TaffyTree<()>;
-        if raw_ptr.is_null() {
-            return -2;
-        }
         let tree: &mut TaffyTree<()> = &mut *raw_ptr;
         let res = tree.new_leaf(style);
         res.map_or(-1, |v| <NodeId as Into<u64>>::into(v) as jlong) as jlong
@@ -50,7 +89,7 @@ pub extern "system" fn Java_com_dioxuslabs_taffy_TaffyTree_newLeaf<'local>(
 
 #[no_mangle]
 #[allow(clippy::not_unsafe_ptr_arg_deref)]
-pub extern "system" fn Java_com_dioxuslabs_taffy_TaffyTree_newWithChildren<'local>(
+pub extern "system" fn Java_com_dioxuslabs_taffy_TaffyTree_nvNewWithChildren<'local>(
     mut env: JNIEnv<'local>,
     _class: JClass<'local>,
     pointer: jlong,
@@ -62,16 +101,254 @@ pub extern "system" fn Java_com_dioxuslabs_taffy_TaffyTree_newWithChildren<'loca
         let list = JValueOwned::from(JObject::from_raw(children));
         let children = &get_list(&mut env, list, opt_node_id_from_object);
 
+        let raw_ptr: *mut TaffyTree<()> = pointer as *mut TaffyTree<()>;
+        let tree: &mut TaffyTree<()> = &mut *raw_ptr;
+        let res = tree.new_with_children(style, children);
+        res.map_or(-1, |v| <NodeId as Into<u64>>::into(v) as jlong) as jlong
+    }
+}
+
+#[no_mangle]
+pub extern "system" fn Java_com_dioxuslabs_taffy_TaffyTree_nvChildCount<'local>(
+    mut env: JNIEnv<'local>,
+    _class: JClass<'local>,
+    pointer: jlong,
+    node: jlong,
+) -> jint {
+    let node = node_id_from_primitive(&mut env, JValueOwned::from(node));
+    let raw_ptr: *mut TaffyTree<()> = pointer as *mut TaffyTree<()>;
+    if raw_ptr.is_null() {
+        return -2;
+    }
+    let tree: &mut TaffyTree<()> = unsafe { &mut *raw_ptr };
+    tree.child_count(node) as jint
+}
+
+#[no_mangle]
+pub extern "system" fn Java_com_dioxuslabs_taffy_TaffyTree_nvClear<'local>(
+    _env: JNIEnv<'local>,
+    _class: JClass<'local>,
+    pointer: jlong,
+) {
+    unsafe {
         let raw_ptr: *mut TaffyTree<()> = pointer as *mut TaffyTree<()>;
         if raw_ptr.is_null() {
-            return -2;
+            return;
         }
         let tree: &mut TaffyTree<()> = &mut *raw_ptr;
-        let res = tree.new_with_children(style, children);
+        tree.clear()
+    }
+}
+
+#[no_mangle]
+pub extern "system" fn Java_com_dioxuslabs_taffy_TaffyTree_nvRemove<'local>(
+    mut env: JNIEnv<'local>,
+    _class: JClass<'local>,
+    pointer: jlong,
+    node: jlong,
+) -> jlong {
+    unsafe {
+        let raw_ptr: *mut TaffyTree<()> = pointer as *mut TaffyTree<()>;
+        let tree: &mut TaffyTree<()> = &mut *raw_ptr;
+
+        let node = node_id_from_primitive(&mut env, JValueOwned::from(node));
+        let res = tree.remove(node);
+
+        res.map_or(-1, |v| <NodeId as Into<u64>>::into(v) as jlong) as jlong
+    }
+}
+
+#[no_mangle]
+pub extern "system" fn Java_com_dioxuslabs_taffy_TaffyTree_nvAddChild<'local>(
+    mut env: JNIEnv<'local>,
+    _class: JClass<'local>,
+    pointer: jlong,
+    parent: jlong,
+    child: jlong,
+) {
+    unsafe {
+        let raw_ptr: *mut TaffyTree<()> = pointer as *mut TaffyTree<()>;
+        let tree: &mut TaffyTree<()> = &mut *raw_ptr;
+
+        let parent_node = node_id_from_primitive(&mut env, JValueOwned::from(parent));
+        let child_node = node_id_from_primitive(&mut env, JValueOwned::from(child));
+        tree.add_child(parent_node, child_node).expect("Failed to add child");
+    }
+}
+
+#[no_mangle]
+pub extern "system" fn Java_com_dioxuslabs_taffy_TaffyTree_nvInsertChildAtIndex<'local>(
+    mut env: JNIEnv<'local>,
+    _class: JClass<'local>,
+    pointer: jlong,
+    parent: jlong,
+    child_index: jint,
+    child: jlong,
+) {
+    unsafe {
+        let raw_ptr: *mut TaffyTree<()> = pointer as *mut TaffyTree<()>;
+        let tree: &mut TaffyTree<()> = &mut *raw_ptr;
+
+        let parent_node = node_id_from_primitive(&mut env, JValueOwned::from(parent));
+        let child_node = node_id_from_primitive(&mut env, JValueOwned::from(child));
+        tree.insert_child_at_index(parent_node, child_index as usize, child_node).expect("Failed to insert child");
+    }
+}
+
+#[no_mangle]
+#[allow(clippy::not_unsafe_ptr_arg_deref)]
+pub extern "system" fn Java_com_dioxuslabs_taffy_TaffyTree_nvSetChildren<'local>(
+    mut env: JNIEnv<'local>,
+    _class: JClass<'local>,
+    pointer: jlong,
+    parent: jlong,
+    children: jobject,
+) {
+    unsafe {
+        let raw_ptr: *mut TaffyTree<()> = pointer as *mut TaffyTree<()>;
+        let tree: &mut TaffyTree<()> = &mut *raw_ptr;
+
+        let parent_node = node_id_from_primitive(&mut env, JValueOwned::from(parent));
+
+        let list = JValueOwned::from(JObject::from_raw(children));
+        let children = &get_list(&mut env, list, opt_node_id_from_object);
+
+        tree.set_children(parent_node, children).expect("Failed to set children");
+    }
+}
+
+#[no_mangle]
+pub extern "system" fn Java_com_dioxuslabs_taffy_TaffyTree_nvRemoveChild<'local>(
+    mut env: JNIEnv<'local>,
+    _class: JClass<'local>,
+    pointer: jlong,
+    parent: jlong,
+    child: jlong,
+) -> jlong {
+    unsafe {
+        let raw_ptr: *mut TaffyTree<()> = pointer as *mut TaffyTree<()>;
+        let tree: &mut TaffyTree<()> = &mut *raw_ptr;
+
+        let parent_node = node_id_from_primitive(&mut env, JValueOwned::from(parent));
+        let child_node = node_id_from_primitive(&mut env, JValueOwned::from(child));
+
+        let res = tree.remove_child(parent_node, child_node);
+        res.map_or(-1, |v| <NodeId as Into<u64>>::into(v) as jlong) as jlong
+    }
+}
+
+#[no_mangle]
+pub extern "system" fn Java_com_dioxuslabs_taffy_TaffyTree_nvRemoveChildAtIndex<'local>(
+    mut env: JNIEnv<'local>,
+    _class: JClass<'local>,
+    pointer: jlong,
+    parent: jlong,
+    child_index: jint,
+) -> jlong {
+    unsafe {
+        let raw_ptr: *mut TaffyTree<()> = pointer as *mut TaffyTree<()>;
+        let tree: &mut TaffyTree<()> = &mut *raw_ptr;
+
+        let parent_node = node_id_from_primitive(&mut env, JValueOwned::from(parent));
+
+        let res = tree.remove_child_at_index(parent_node, child_index as usize);
+        res.map_or(-1, |v| <NodeId as Into<u64>>::into(v) as jlong) as jlong
+    }
+}
+
+#[no_mangle]
+pub extern "system" fn Java_com_dioxuslabs_taffy_TaffyTree_nvReplaceChildAtIndex<'local>(
+    mut env: JNIEnv<'local>,
+    _class: JClass<'local>,
+    pointer: jlong,
+    parent: jlong,
+    child_index: jint,
+    new_child: jlong,
+) -> jlong {
+    unsafe {
+        let raw_ptr: *mut TaffyTree<()> = pointer as *mut TaffyTree<()>;
+        let tree: &mut TaffyTree<()> = &mut *raw_ptr;
+
+        let parent_node = node_id_from_primitive(&mut env, JValueOwned::from(parent));
+        let new_child_node = node_id_from_primitive(&mut env, JValueOwned::from(new_child));
+
+        let res = tree.replace_child_at_index(parent_node, child_index as usize, new_child_node);
+        res.map_or(-1, |v| <NodeId as Into<u64>>::into(v) as jlong) as jlong
+    }
+}
+
+#[no_mangle]
+pub extern "system" fn Java_com_dioxuslabs_taffy_TaffyTree_nvChildAtIndex<'local>(
+    mut env: JNIEnv<'local>,
+    _class: JClass<'local>,
+    pointer: jlong,
+    parent: jlong,
+    child_index: jint,
+) -> jlong {
+    unsafe {
+        let raw_ptr: *mut TaffyTree<()> = pointer as *mut TaffyTree<()>;
+        let tree: &mut TaffyTree<()> = &mut *raw_ptr;
+
+        let parent_node = node_id_from_primitive(&mut env, JValueOwned::from(parent));
+
+        let res = tree.child_at_index(parent_node, child_index as usize);
+        res.map_or(-1, |v| <NodeId as Into<u64>>::into(v) as jlong) as jlong
+    }
+}
+
+#[no_mangle]
+pub extern "system" fn Java_com_dioxuslabs_taffy_TaffyTree_nvTotalNodeCount<'local>(
+    _env: JNIEnv<'local>,
+    _class: JClass<'local>,
+    pointer: jlong,
+) -> jint {
+    unsafe {
+        let raw_ptr: *mut TaffyTree<()> = pointer as *mut TaffyTree<()>;
+        let tree: &mut TaffyTree<()> = &mut *raw_ptr;
+
+        tree.total_node_count() as jint
+    }
+}
+
+#[no_mangle]
+pub extern "system" fn Java_com_dioxuslabs_taffy_TaffyTree_nvParent<'local>(
+    mut env: JNIEnv<'local>,
+    _class: JClass<'local>,
+    pointer: jlong,
+    child_id: jlong
+) -> jlong {
+    unsafe {
+        let raw_ptr: *mut TaffyTree<()> = pointer as *mut TaffyTree<()>;
+        let tree: &mut TaffyTree<()> = &mut *raw_ptr;
+
+        let child_node = node_id_from_primitive(&mut env, JValueOwned::from(child_id));
+
+        let res = tree.parent(child_node);
         res.map_or(-1, |v| <NodeId as Into<u64>>::into(v) as jlong) as jlong
     }
 }
 
+#[no_mangle]
+#[allow(clippy::not_unsafe_ptr_arg_deref)]
+pub extern "system" fn Java_com_dioxuslabs_taffy_TaffyTree_nvSetStyle<'local>(
+    mut env: JNIEnv<'local>,
+    _class: JClass<'local>,
+    pointer: jlong,
+    node: jlong,
+    style: jobject,
+) {
+    unsafe {
+        let raw_ptr: *mut TaffyTree<()> = pointer as *mut TaffyTree<()>;
+        let tree: &mut TaffyTree<()> = &mut *raw_ptr;
+
+        let node = node_id_from_primitive(&mut env, JValueOwned::from(node));
+
+        let style = get_style(&mut env, &JObject::from_raw(style));
+
+        tree.set_style(node, style).expect("Failed to set children");
+    }
+}
+
 #[no_mangle]
 #[allow(clippy::not_unsafe_ptr_arg_deref)]
 pub extern "system" fn Java_com_dioxuslabs_taffy_TaffyTree_computeLayout<'local>(
@@ -97,21 +374,23 @@ pub extern "system" fn Java_com_dioxuslabs_taffy_TaffyTree_computeLayout<'local>
 }
 
 #[no_mangle]
-pub extern "system" fn Java_com_dioxuslabs_taffy_TaffyTree_childCount<'local>(
+pub extern "system" fn Java_com_dioxuslabs_taffy_TaffyTree_nvPrintTree<'local>(
     mut env: JNIEnv<'local>,
     _class: JClass<'local>,
     pointer: jlong,
-    node: jlong,
-) -> jint {
-    let node = node_id_from_primitive(&mut env, JValueOwned::from(node));
-    let raw_ptr: *mut TaffyTree<()> = pointer as *mut TaffyTree<()>;
-    if raw_ptr.is_null() {
-        return -2;
+    node: jlong
+) {
+    unsafe {
+        let raw_ptr: *mut TaffyTree<()> = pointer as *mut TaffyTree<()>;
+        if raw_ptr.is_null() {
+            return;
+        }
+        let tree: &mut TaffyTree<()> = &mut *raw_ptr;
+        let node = node_id_from_primitive(&mut env, JValueOwned::from(node));
+        tree.print_tree(node)
     }
-    let tree: &mut TaffyTree<()> = unsafe { &mut *raw_ptr };
-    let res = tree.child_count(node);
-    res as jint
 }
+
 #[no_mangle]
 pub extern "system" fn Java_com_dioxuslabs_taffy_TaffyTree_layout<'local>(
     mut env: JNIEnv<'local>,