Adds read-write API generation support for Java code generation

code-gen-projects/input/struct_with_fields.ion

@@ -2,4 +2,5 @@
  A: "hello",
  B: 12,
  C: ["foo", "bar", "baz"],
+ D: 10e2
 }

code-gen-projects/java/code-gen-demo/src/test/java/org/example/CodeGenTest.java

@@ -3,24 +3,71 @@
 import org.junit.jupiter.api.Test;
 import static org.junit.jupiter.api.Assertions.*;
 import java.util.ArrayList;
+import com.amazon.ion.system.IonReaderBuilder;
+import com.amazon.ion.IonReader;
+import com.amazon.ion.system.IonTextWriterBuilder;
+import com.amazon.ion.IonWriter;
+import com.amazon.ion.IonSystem;
+import com.amazon.ion.system.IonSystemBuilder;
+import com.amazon.ion.IonLoader;
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.FileInputStream;
+import java.io.File;
 
 class CodeGenTest {
-    // TODO: Add roundtrip tests after read-write APIs are supported for Java code generation
+    private static final IonSystem ionSystem = IonSystemBuilder.standard().build();
+    private static final IonLoader ionLoader = ionSystem.getLoader();
+
     @Test void getterAndSetterTestForStructWithFields() {
          ArrayList<String> a = new ArrayList<String>();
          a.add("foo");
          a.add("bar");
          a.add("baz");
-         StructWithFields s = new StructWithFields("hello", 12, new AnonymousType2(a));
+         StructWithFields s = new StructWithFields("hello", 12, new AnonymousType2(a), 10e2);
          assertEquals("hello", s.getA(), "s.getA() should return \"hello\"");
          assertEquals(12, s.getB(), "s.getB() should return `12`");
          assertEquals(3, s.getC().getValue().size(), "s.getC().getValue() should return ArrayList fo size 3");
+         assertEquals(10e2, s.getD(), "s.getD() should return `10e2`");
     }
 
     @Test void getterAndSetterTestForNestedStruct() {
-             NestedStruct n = new NestedStruct("hello", 12, new AnonymousType1(false));
-             assertEquals("hello", n.getA(), "n.getA() should return \"hello\"");
-             assertEquals(12, n.getB(), "n.getB() should return `12`");
-             assertEquals(false, n.getC().getD(), "n.getC().getD() should return `false`");
+         NestedStruct n = new NestedStruct("hello", 12, new AnonymousType1(false));
+         assertEquals("hello", n.getA(), "n.getA() should return \"hello\"");
+         assertEquals(12, n.getB(), "n.getB() should return `12`");
+         assertEquals(false, n.getC().getD(), "n.getC().getD() should return `false`");
+    }
+
+    @Test void roundtripTestForStructWithFields() throws IOException {
+        File f = new File("./../../input/struct_with_fields.ion");
+        InputStream inputStream = new FileInputStream(f);
+        IonTextWriterBuilder b = IonTextWriterBuilder.standard();
+        ByteArrayOutputStream out = new ByteArrayOutputStream();
+        IonReaderBuilder readerBuilder = IonReaderBuilder.standard();
+        try (IonReader reader = readerBuilder.build(inputStream)) {
+            reader.next();
+            StructWithFields s = StructWithFields.readFrom(reader);
+            IonWriter writer = b.build(out);
+            s.writeTo(writer);
+            writer.close();
         }
+        assertEquals(ionLoader.load(f), ionLoader.load(out.toByteArray()));
+    }
+
+    @Test void roundtripTestForNestedStruct() throws IOException {
+        File f = new File("./../../input/nested_struct.ion");
+        InputStream inputStream = new FileInputStream(f);
+        IonTextWriterBuilder b = IonTextWriterBuilder.standard();
+        ByteArrayOutputStream out = new ByteArrayOutputStream();
+        IonReaderBuilder readerBuilder = IonReaderBuilder.standard();
+        try (IonReader reader = readerBuilder.build(inputStream)) {
+            reader.next();
+            NestedStruct n = NestedStruct.readFrom(reader);
+            IonWriter writer = b.build(out);
+            n.writeTo(writer);
+            writer.close();
+        }
+        assertEquals(ionLoader.load(f), ionLoader.load(out.toByteArray()));
+    }
 }

code-gen-projects/schema/struct_with_fields.isl

@@ -3,7 +3,8 @@ type::{
  fields: {
     A: string,
     B: int,
-    C: { element: string }
+    C: { element: string },
+    D: float,
  }
 }
 

src/bin/ion/commands/beta/generate/templates/java/class.templ

@@ -1,5 +1,10 @@
 package {{ namespace }};
 import java.util.ArrayList;
+import com.amazon.ion.IonReader;
+import com.amazon.ion.IonException;
+import com.amazon.ion.IonWriter;
+import com.amazon.ion.IonType;
+import java.io.IOException;
 
 public final class {{ target_kind_name }} {
 {% for field in fields -%}
@@ -16,4 +21,110 @@ public final class {{ target_kind_name }} {
         return this.{{ field.name | camel }};
     }
     {% endfor %}
+
+    public static {{ target_kind_name }} readFrom(IonReader reader) {
+        {# Intializes all the fields of this class #}
+        {% for field in fields -%}
+        {{ field.value }} {{ field.name | camel }} =
+            {% if field.value == "boolean" %}
+                false
+            {% elif field.value == "int" or field.value == "double" %}
+                0
+            {% else %}
+                null
+            {% endif %};
+        {% endfor %}
+        {% if abstract_data_type == "Value"%}
+            {# Reads `Value` class with a signle field `value` #}
+            value = {% if fields[0].value | is_built_in_type %}
+                        {% if fields[0].value == "bytes[]" %}
+                                reader.newBytes();
+                        {% else %}
+                             reader.{{ fields[0].value | camel }}Value();
+                        {% endif %}
+                     {% else %}
+                        {{ fields[0].value }}.readFrom(reader);
+                     {% endif %}
+        {% elif abstract_data_type is object and abstract_data_type is containing("Structure") %}
+            {# Reads `Structure` class with multiple fields based on `field.name` #}
+            reader.stepIn();
+            while (reader.hasNext()) {
+                reader.next();
+                String fieldName = reader.getFieldName();
+                switch(fieldName) {
+                    {% for field in fields %}
+                    case "{{ field.name }}":
+                        {{ field.name | camel }} = {% if field.value | is_built_in_type %}
+                                                       {% if field.value == "bytes[]" %}
+                                                               reader.newBytes();
+                                                       {% else %}
+                                                            reader.{{ field.value | camel }}Value();
+                                                       {% endif %}
+                                                    {% else %}
+                                                       {{ field.value }}.readFrom(reader);
+                                                    {% endif %}
+                        break;
+                    {% endfor %}
+                    default:
+                        throw new IonException("Can not read field name:" + fieldName + " for {{ target_kind_name }} as it doesn't exist in the given schema type definition.");
+                }
+            }
+            reader.stepOut();
+        {% elif abstract_data_type is object and abstract_data_type is containing("Sequence") %}
+            {# Reads `Sequence` class with a single field `value` that is an `ArraList` #}
+            reader.stepIn();
+            value = new {{ fields[0].value }}();
+            {# Iterate through the `ArraList` and read each element in it based on the data type provided in `abstract_data_type[Sequence]` #}
+            while (reader.hasNext()) {
+                reader.next();
+                {% if abstract_data_type["Sequence"] | is_built_in_type == false %}
+                    value.add({{ abstract_data_type["Sequence"] }}.readFrom(reader));
+                {% else %}
+                    {% if abstract_data_type["Sequence"] == "bytes[]" %}
+                        value.add(reader.newBytes());
+                    {% else %}
+                        value.add(reader.{{ abstract_data_type["Sequence"] | camel }}Value());
+                    {% endif %}
+                {% endif %}
+            }
+            reader.stepOut();
+        {% endif %}
+        return new {{ target_kind_name }}({% for field in fields | sort(attribute="name") -%}{{ field.name | camel }}{% if not loop.last %},{% endif %}{% endfor %});
+    }
+
+    public void writeTo(IonWriter writer) throws IOException {
+         {% if abstract_data_type == "Value" %}
+            {# Writes `Value` class with a signle field `value` as an Ion value #}
+            {% for field in fields %}
+                {% if field.value | is_built_in_type == false  %}
+                    this.{{ field.name | camel }}.writeTo(writer)?;
+                {% else %}
+                    writer.write{% if field.isl_type_name == "symbol" %}Symbol{% else %}{{ field.isl_type_name | upper_camel }}{% endif %}(this.value);
+                {% endif %}
+            {% endfor %}
+         {% elif abstract_data_type is object and abstract_data_type is containing("Structure") %}
+            {# Writes `Structure` class with multiple fields based on `field.name` as an Ion struct #}
+             writer.stepIn(IonType.STRUCT);
+             {% for field in fields %}
+             writer.setFieldName("{{ field.name }}");
+                 {% if field.value | is_built_in_type == false %}
+                     this.{{ field.name | camel }}.writeTo(writer);
+                 {% else %}
+                     writer.write{% if field.isl_type_name == "symbol" %}Symbol{% else %}{{ field.isl_type_name | upper_camel }}{% endif %}(this.{{ field.name | camel }});
+                 {% endif %}
+             {% endfor %}
+             writer.stepOut();
+         {% elif abstract_data_type is object and abstract_data_type is containing("Sequence") %}
+            {# Writes `Sequence` class with a single field `value` that is an `ArraList` as an Ion sequence #}
+            writer.stepIn(IonType.LIST);
+            for ({{ abstract_data_type["Sequence"] }} value: this.value) {
+                 {% if abstract_data_type["Sequence"] | is_built_in_type  == false %}
+                     value.writeTo(writer);
+                 {% else %}
+                    writer.write{% if fields[0].isl_type_name == "symbol" %}Symbol{% else %}{{ abstract_data_type["Sequence"] | upper_camel }}{% endif %}(value);
+                 {% endif %}
+            }
+            writer.stepOut();
+        {% endif %}
+    }
 }

src/bin/ion/commands/beta/generate/utils.rs

@@ -88,7 +88,7 @@ impl Language for JavaLanguage {
     }
 
     fn is_built_in_type(name: &str) -> bool {
-        matches!(name, "int" | "String" | "boolean" | "byte[]" | "float")
+        matches!(name, "int" | "String" | "boolean" | "byte[]" | "double")
     }
 
     fn template_name(template: &Template) -> String {