feat(java): introduce new 'compact' row encoding

compact encoding will store fixed sized fields inline,
relaxes alignment considerations to preserve alignment where possible
but using space more effectively

Author: stevenschlansker

java/fory-core/src/main/java/org/apache/fory/builder/CodecBuilder.java

@@ -117,6 +117,8 @@ public CodecBuilder(CodegenContext ctx, TypeRef<?> beanType) {
     // For example user class named as `Date`/`List`/`MemoryBuffer`
   }
 
+  public abstract String codecClassName(Class<?> cls);
+
   /** Generate codec class code. */
   public abstract String genCode();
 

java/fory-core/src/main/java/org/apache/fory/memory/MemoryBuffer.java

@@ -40,7 +40,7 @@
  *   <li>additional binary compare, swap, and copy methods.
  *   <li>little-endian access.
  *   <li>independent read/write index.
- *   <li>variant int/long encoding.
+ *   <li>varint int/long encoding.
  *   <li>aligned int/long encoding.
  * </ul>
  *

java/fory-format/src/main/java/org/apache/fory/format/encoder/ArrayCodecBuilder.java

@@ -0,0 +1,124 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you 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.apache.fory.format.encoder;
+
+import static org.apache.fory.type.TypeUtils.getRawType;
+
+import java.lang.reflect.Constructor;
+import java.util.Collection;
+import java.util.HashSet;
+import java.util.Set;
+import java.util.function.Function;
+import java.util.function.Supplier;
+import org.apache.arrow.vector.types.pojo.Field;
+import org.apache.arrow.vector.types.pojo.Schema;
+import org.apache.fory.format.row.binary.writer.BinaryArrayWriter;
+import org.apache.fory.format.type.DataTypes;
+import org.apache.fory.format.type.TypeInference;
+import org.apache.fory.reflect.TypeRef;
+import org.apache.fory.type.TypeUtils;
+
+public class ArrayCodecBuilder<C extends Collection<?>>
+    extends BaseCodecBuilder<ArrayCodecBuilder<C>> {
+
+  private final TypeRef<C> collectionType;
+
+  ArrayCodecBuilder(final TypeRef<C> collectionType) {
+    super(TypeInference.inferSchema(collectionType, false));
+    this.collectionType = collectionType;
+  }
+
+  public Supplier<ArrayEncoder<C>> buildForArray() {
+    final Function<BinaryArrayWriter, ArrayEncoder<C>> arrayEncoderFactory =
+        buildForArrayWithCustomWriter();
+    final Schema collectionSchema = TypeInference.inferSchema(collectionType, false);
+    final Field field = DataTypes.fieldOfSchema(collectionSchema, 0);
+    return new Supplier<ArrayEncoder<C>>() {
+      @Override
+      public ArrayEncoder<C> get() {
+        final BinaryArrayWriter writer = codecFactory.newArrayWriter(field);
+        return arrayEncoderFactory.apply(writer);
+      }
+    };
+  }
+
+  public Function<BinaryArrayWriter, ArrayEncoder<C>> buildForArrayWithCustomWriter() {
+    loadArrayInnerCodecs(collectionType);
+    final Function<BinaryArrayWriter, GeneratedArrayEncoder> arrayEncoderFactory =
+        arrayEncoderFactory(collectionType);
+    return new Function<BinaryArrayWriter, ArrayEncoder<C>>() {
+      @Override
+      public ArrayEncoder<C> apply(final BinaryArrayWriter writer) {
+        return new BeanArrayEncoder<>(writer, writer.getField(), arrayEncoderFactory.apply(writer));
+      }
+    };
+  }
+
+  private void loadArrayInnerCodecs(final TypeRef<?> collectionType) {
+    final Set<TypeRef<?>> set = new HashSet<>();
+    Encoders.findBeanToken(collectionType, set);
+    if (set.isEmpty()) {
+      throw new IllegalArgumentException("can not find bean class.");
+    }
+
+    TypeRef<?> typeRef = null;
+    for (final TypeRef<?> tt : set) {
+      typeRef = set.iterator().next();
+      Encoders.loadOrGenRowCodecClass(getRawType(tt), codecFactory);
+    }
+  }
+
+  Function<BinaryArrayWriter, GeneratedArrayEncoder> arrayEncoderFactory(
+      final TypeRef<? extends Collection<?>> collectionType) {
+    final TypeRef<?> elementType = TypeUtils.getElementType(collectionType);
+    final Class<?> arrayCodecClass =
+        Encoders.loadOrGenArrayCodecClass(collectionType, elementType, codecFactory);
+
+    Constructor<? extends GeneratedArrayEncoder> constructor;
+    try {
+      constructor =
+          arrayCodecClass.asSubclass(GeneratedArrayEncoder.class).getConstructor(Object[].class);
+    } catch (final NoSuchMethodException e) {
+      throw new EncoderException(
+          "Failed to construct array codec for "
+              + collectionType
+              + " with element class "
+              + elementType,
+          e);
+    }
+    return new Function<BinaryArrayWriter, GeneratedArrayEncoder>() {
+      @Override
+      public GeneratedArrayEncoder apply(final BinaryArrayWriter writer) {
+        final Field field = writer.getField();
+        final Object references = new Object[] {field, writer, fory};
+        try {
+          return constructor.newInstance(references);
+        } catch (final ReflectiveOperationException e) {
+          throw new EncoderException(
+              "Failed to construct array codec for "
+                  + collectionType
+                  + " with element class "
+                  + elementType,
+              e);
+        }
+      }
+    };
+  }
+}

java/fory-format/src/main/java/org/apache/fory/format/encoder/ArrayEncoderBuilder.java

@@ -136,7 +136,7 @@ public String genCode() {
   @Override
   public Expression buildEncodeExpression() {
     Expression.Reference arrayWriter =
-        new Expression.Reference(ROOT_ARRAY_WRITER_NAME, arrayWriterTypeToken, false);
+        new Expression.Reference(ROOT_ARRAY_WRITER_NAME, arrayWriterType(), false);
     Expression.ListExpression expressions = new Expression.ListExpression();
 
     Expression.Reference inputObject =
@@ -148,7 +148,7 @@ public Expression buildEncodeExpression() {
 
     Expression.Reference fieldExpr = new Expression.Reference(FIELD_NAME, ARROW_FIELD_TYPE, false);
     Expression listExpression =
-        serializeForArrayByWriter(array, arrayWriter, arrayToken, fieldExpr);
+        serializeForArrayByWriter(array, arrayWriter, arrayToken, null, fieldExpr);
 
     expressions.add(listExpression);