Added Java classes field accessing support.

Author: astonbitecode

java/src/main/java/org/astonbitecode/j4rs/api/NativeInvocation.java

@@ -66,6 +66,13 @@ public interface NativeInvocation<T> extends ObjectValue, JsonValue {
      */
     void initializeCallbackChannel(long channelAddress);
 
+    /**
+     * Retrieves the instance held under the Field fieldName
+     * @param fieldName
+     * @return A {@link NativeInvocation} instance containing the defined field.
+     */
+    NativeInvocation field(String fieldName);
+
     /**
      * Casts a the object that is contained in a NativeInvocation to an object of class clazz.
      *

java/src/main/java/org/astonbitecode/j4rs/api/invocation/EagerJsonInvocationImpl.java

@@ -56,6 +56,11 @@ public void initializeCallbackChannel(long channelAddress) {
         throw new RuntimeException("Not implemented yet. Please use the JsonInvocationImpl instead");
     }
 
+    @Override
+    public NativeInvocation field(String methodName) {
+        throw new RuntimeException("Not implemented yet. Please use the JsonInvocationImpl instead");
+    }
+
     @Override
     public T getObject() {
         throw new RuntimeException("Not implemented yet. Please use the JsonInvocationImpl instead");

java/src/main/java/org/astonbitecode/j4rs/api/invocation/JsonInvocationImpl.java

@@ -23,6 +23,7 @@
 import org.astonbitecode.j4rs.errors.InvocationException;
 import org.astonbitecode.j4rs.rust.RustPointer;
 
+import java.lang.reflect.Field;
 import java.lang.reflect.Method;
 import java.util.Arrays;
 
@@ -44,10 +45,6 @@ public JsonInvocationImpl(T instance, Class<T> clazz) {
 
     @Override
     public NativeInvocation invoke(String methodName, InvocationArg... args) {
-        // Check the existence of the instance to invoke
-        if (this.object == null) {
-            throw new InvocationException("Cannot invoke the class " + this.clazz.getName() + ". It is not instantiated yet.");
-        }
         // Invoke the instance
         try {
             CreatedInstance createdInstance = invokeMethod(methodName, gen.generateArgObjects(args));
@@ -97,6 +94,16 @@ public void initializeCallbackChannel(long channelAddress) {
         }
     }
 
+    @Override
+    public NativeInvocation field(String fieldName) {
+        try {
+            CreatedInstance createdInstance = getField(fieldName);
+            return new JsonInvocationImpl(createdInstance.object, createdInstance.clazz);
+        } catch (Exception error) {
+            throw new InvocationException("Error while accessing field " + fieldName + " of Class " + this.clazz.getName(), error);
+        }
+    }
+
     @Override
     public T getObject() {
         return object;
@@ -113,6 +120,12 @@ public String getJson() {
         return jsonValue.getJson();
     }
 
+    CreatedInstance getField(String fieldName) throws Exception {
+        Field field = this.clazz.getField(fieldName);
+        Object fieldObject = field.get(this.object);
+        return new CreatedInstance(field.getType(), fieldObject);
+    }
+
     CreatedInstance invokeMethod(String methodName, GeneratedArg[] generatedArgs) throws Exception {
         Class[] argTypes = Arrays.stream(generatedArgs)
                 .map(invGeneratedArg -> {

java/src/test/java/org/astonbitecode/j4rs/api/invocation/JsonInvocationImplTest.java

@@ -104,4 +104,70 @@ public void invokeMethodNotFoundInHierarchy() {
         NativeInvocation ni = new JsonInvocationImpl(new GrandchildDummy(), GrandchildDummy.class);
         ni.invoke("nonExisting");
     }
+
+    @Test
+    public void getFieldInstance() {
+        NativeInvocation ni = new JsonInvocationImpl(new DummyWithFields(), DummyWithFields.class);
+
+        NativeInvocation res1 = ni.field("pubInt");
+        Integer i1 = (Integer) res1.getObject();
+        assert (i1.equals(11));
+
+        try {
+            NativeInvocation res2 = ni.field("packageInt");
+            res2.getObject();
+            assert (false);
+        } catch (InvocationException ie) {
+            assert (true);
+        }
+
+        try {
+            NativeInvocation res3 = ni.field("protectedInt");
+            res3.getObject();
+            assert (false);
+        } catch (InvocationException ie) {
+            assert (true);
+        }
+
+        try {
+            NativeInvocation res4 = ni.field("privateInt");
+            res4.getObject();
+            assert (false);
+        } catch (InvocationException ie) {
+            assert (true);
+        }
+    }
+
+    @Test
+    public void getFieldInstanceInHierarchy() {
+        NativeInvocation ni = new JsonInvocationImpl(new ChildOfDummyWithFields(), ChildOfDummyWithFields.class);
+
+        NativeInvocation res1 = ni.field("pubInt");
+        Integer i1 = (Integer) res1.getObject();
+        assert (i1.equals(11));
+
+        try {
+            NativeInvocation res2 = ni.field("packageInt");
+            res2.getObject();
+            assert (false);
+        } catch (InvocationException ie) {
+            assert (true);
+        }
+
+        try {
+            NativeInvocation res3 = ni.field("protectedInt");
+            res3.getObject();
+            assert (false);
+        } catch (InvocationException ie) {
+            assert (true);
+        }
+
+        try {
+            NativeInvocation res4 = ni.field("privateInt");
+            res4.getObject();
+            assert (false);
+        } catch (InvocationException ie) {
+            assert (true);
+        }
+    }
 }

java/src/test/java/org/astonbitecode/j4rs/utils/ChildOfDummyWithFields.java

@@ -0,0 +1,18 @@
+/*
+ * Copyright 2019 astonbitecode
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.astonbitecode.j4rs.utils;
+
+public class ChildOfDummyWithFields extends DummyWithFields {
+}

java/src/test/java/org/astonbitecode/j4rs/utils/DummyWithFields.java

@@ -0,0 +1,22 @@
+/*
+ * Copyright 2019 astonbitecode
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.astonbitecode.j4rs.utils;
+
+public class DummyWithFields {
+    public Integer pubInt = 11;
+    Integer packageInt = 111;
+    protected Integer protectedInt = 1111;
+    private Integer privateInt = 1111;
+}

rust/jassets/j4rs-0.7.0-SNAPSHOT-jar-with-dependencies.jar

@@ -459,6 +459,33 @@ impl Jvm {
         }
     }
 
+    /// Retrieves the static class `class_name`.
+    pub fn static_class(&self, class_name: &str) -> errors::Result<Instance> {
+        debug(&format!("Retrieving static class {}", class_name));
+        unsafe {
+            // Factory invocation - first argument: create a jstring to pass as argument for the class_name
+            let class_name_jstring: jstring = (self.jni_new_string_utf)(
+                self.jni_env,
+                utils::to_java_string(class_name),
+            );
+            // Call the method of the factory that creates a NativeInvocation for static calls to methods of class `class_name`.
+            // This returns a NativeInvocation that acts like a proxy to the Java world.
+            let native_invocation_instance = (self.jni_call_static_object_method)(
+                self.jni_env,
+                self.factory_class,
+                self.factory_create_for_static_method,
+                class_name_jstring,
+            );
+
+            delete_java_local_ref(self.jni_env, class_name_jstring);
+
+            let native_invocation_global_instance = create_global_ref_from_local_ref(native_invocation_instance, self.jni_env)?;
+
+            // Create and return the Instance
+            self.do_return(Instance::from(native_invocation_global_instance)?)
+        }
+    }
+
     /// Creates a new Java Array with elements of the class `class_name`.
     /// The array will have the `InvocationArg`s populated.
     /// The `InvocationArg`s __must__ be of type _class_name_.
@@ -576,6 +603,47 @@ impl Jvm {
         }
     }
 
+    /// Retrieves the field `field_name` of a created `Instance`.
+    pub fn field(&self, instance: &Instance, field_name: &str) -> errors::Result<Instance> {
+        debug(&format!("Retrieving field {} of class {}", field_name, instance.class_name));
+        unsafe {
+            let invoke_method_signature = format!(
+                "(Ljava/lang/String;)L{};",
+                INVO_IFACE_NAME);
+            // Get the method ID for the `NativeInvocation.field`
+            let field_method = (self.jni_get_method_id)(
+                self.jni_env,
+                self.native_invocation_class,
+                utils::to_java_string("field"),
+                utils::to_java_string(invoke_method_signature.as_ref()),
+            );
+
+            // First argument: create a jstring to pass as argument for the field_name
+            let field_name_jstring: jstring = (self.jni_new_string_utf)(
+                self.jni_env,
+                utils::to_java_string(field_name),
+            );
+
+            // Call the method of the instance
+            let native_invocation_instance = (self.jni_call_object_method)(
+                self.jni_env,
+                instance.jinstance,
+                field_method,
+                field_name_jstring,
+            );
+
+            let native_invocation_global_instance = create_global_ref_from_local_ref(native_invocation_instance, self.jni_env)?;
+            // Prevent memory leaks from the created local references
+            delete_java_local_ref(self.jni_env, field_name_jstring);
+
+            // Create and return the Instance
+            self.do_return(Instance {
+                jinstance: native_invocation_global_instance,
+                class_name: UNKNOWN_FOR_RUST.to_string(),
+            })
+        }
+    }
+
     /// Invokes the method `method_name` of a created `Instance`, passing an array of `InvocationArg`s.
     /// It returns a Result of `InstanceReceiver` that may be used to get an underlying `Receiver<Instance>`. The result of the invocation will come via this Receiver.
     pub fn invoke_to_channel(&self, instance: &Instance, method_name: &str, inv_args: &[InvocationArg]) -> errors::Result<InstanceReceiver> {
@@ -1677,7 +1745,7 @@ impl<'a> ChainableInstance<'a> {
         Ok(ChainableInstance::new(instance, self.jvm))
     }
 
-    /// Creates a clone of the provided Instance
+    /// Creates a clone of the Instance
     pub fn clone_instance(&self) -> errors::Result<ChainableInstance> {
         let instance = self.jvm.clone_instance(&self.instance)?;
         Ok(ChainableInstance::new(instance, self.jvm))
@@ -1689,10 +1757,17 @@ impl<'a> ChainableInstance<'a> {
         Ok(ChainableInstance::new(instance, self.jvm))
     }
 
+    /// Retrieves the field `field_name` of the `Instance`.
+    pub fn field(&self, field_name: &str) -> errors::Result<ChainableInstance> {
+        let instance = self.jvm.field(&self.instance, field_name)?;
+        Ok(ChainableInstance::new(instance, self.jvm))
+    }
+
     /// Returns the Rust representation of the provided instance
     pub fn to_rust<T>(self) -> errors::Result<T> where T: DeserializeOwned {
         self.jvm.to_rust(self.instance)
     }
+
 }
 
 #[derive(Debug)]

rust/src/api.rs

@@ -278,7 +278,7 @@ mod lib_unit_tests {
         thread::sleep(thousand_millis);
     }
 
-//    #[test]
+    //    #[test]
 //    #[ignore]
     fn _memory_leaks_create_instances_in_different_threads() {
         for i in 0..100000000 {
@@ -496,4 +496,41 @@ mod lib_unit_tests {
 
         assert!(product == 18);
     }
+
+    #[test]
+    fn static_invocation_chain_and_to_rust() {
+        let jvm: Jvm = JvmBuilder::new()
+            .build()
+            .unwrap();
+
+        let static_invocation = jvm.static_class("java.lang.System").unwrap();
+
+        let _: isize = jvm.chain(static_invocation)
+            .invoke("currentTimeMillis", &[]).unwrap()
+            .to_rust().unwrap();
+    }
+
+    #[test]
+    fn access_class_field() {
+        let jvm: Jvm = JvmBuilder::new()
+            .build()
+            .unwrap();
+
+        let static_invocation = jvm.static_class("java.lang.System").unwrap();
+        let field_instance_res = jvm.field(&static_invocation, "out");
+        assert!(field_instance_res.is_ok());
+    }
+
+    #[test]
+    fn java_hello_world() {
+        let jvm: Jvm = JvmBuilder::new()
+            .build()
+            .unwrap();
+
+        let system = jvm.static_class("java.lang.System").unwrap();
+        let _ = jvm.chain(system)
+            .field("out").unwrap()
+            .invoke("println", &vec![InvocationArg::from("Hello World")]).unwrap()
+            .collect();
+    }
 }