AVRO-2307: list of primitive

apache · Jul 24, 2023 · 5148c9d · 5148c9d
1 parent 175b7e5
commit 5148c9d
Show file tree

Hide file tree

Showing 4 changed files with 987 additions and 43 deletions.
diff --git a/lang/java/avro/src/main/java/org/apache/avro/generic/GenericData.java b/lang/java/avro/src/main/java/org/apache/avro/generic/GenericData.java
@@ -317,30 +317,16 @@ public String toString() {
     }
   }
 
-  /** Default implementation of an array. */
-  @SuppressWarnings(value = "unchecked")
-  public static class Array<T> extends AbstractList<T> implements GenericArray<T>, Comparable<GenericArray<T>> {
-    private static final Object[] EMPTY = new Object[0];
+  public static abstract class AbstractArray<T> extends AbstractList<T>
+      implements GenericArray<T>, Comparable<GenericArray<T>> {
     private final Schema schema;
-    private int size;
-    private Object[] elements = EMPTY;
 
-    public Array(int capacity, Schema schema) {
-      if (schema == null || !Type.ARRAY.equals(schema.getType()))
-        throw new AvroRuntimeException("Not an array schema: " + schema);
-      this.schema = schema;
-      if (capacity != 0)
-        elements = new Object[capacity];
-    }
+    protected int size = 0;
 
-    public Array(Schema schema, Collection<T> c) {
+    public AbstractArray(Schema schema) {
       if (schema == null || !Type.ARRAY.equals(schema.getType()))
         throw new AvroRuntimeException("Not an array schema: " + schema);
       this.schema = schema;
-      if (c != null) {
-        elements = new Object[c.size()];
-        addAll(c);
-      }
     }
 
     @Override
@@ -353,23 +339,14 @@ public int size() {
       return size;
     }
 
-    @Override
-    public void clear() {
-      // Let GC do its work
-      Arrays.fill(elements, 0, size, null);
-      size = 0;
-    }
-
     @Override
     public void reset() {
       size = 0;
     }
 
     @Override
-    public void prune() {
-      if (size < elements.length) {
-        Arrays.fill(elements, size, elements.length, null);
-      }
+    public int compareTo(GenericArray<T> that) {
+      return GenericData.get().compare(this, that, this.getSchema());
     }
 
     @Override
@@ -384,7 +361,7 @@ public boolean hasNext() {
 
         @Override
         public T next() {
-          return (T) elements[position++];
+          return AbstractArray.this.get(position++);
         }
 
         @Override
@@ -394,6 +371,57 @@ public void remove() {
       };
     }
 
+    @Override
+    public void reverse() {
+      int left = 0;
+      int right = size - 1;
+
+      while (left < right) {
+        this.swap(left, right);
+
+        left++;
+        right--;
+      }
+    }
+
+    protected abstract void swap(int index1, int index2);
+  }
+
+  /** Default implementation of an array. */
+  @SuppressWarnings(value = "unchecked")
+  public static class Array<T> extends AbstractArray<T> {
+    private static final Object[] EMPTY = new Object[0];
+
+    private Object[] elements = EMPTY;
+
+    public Array(int capacity, Schema schema) {
+      super(schema);
+      if (capacity != 0)
+        elements = new Object[capacity];
+    }
+
+    public Array(Schema schema, Collection<T> c) {
+      super(schema);
+      if (c != null) {
+        elements = new Object[c.size()];
+        addAll(c);
+      }
+    }
+
+    @Override
+    public void clear() {
+      // Let GC do its work
+      Arrays.fill(elements, 0, size, null);
+      size = 0;
+    }
+
+    @Override
+    public void prune() {
+      if (size < elements.length) {
+        Arrays.fill(elements, size, elements.length, null);
+      }
+    }
+
     @Override
     public T get(int i) {
       if (i >= size)
@@ -447,18 +475,10 @@ public int compareTo(GenericArray<T> that) {
     }
 
     @Override
-    public void reverse() {
-      int left = 0;
-      int right = elements.length - 1;
-
-      while (left < right) {
-        Object tmp = elements[left];
-        elements[left] = elements[right];
-        elements[right] = tmp;
-
-        left++;
-        right--;
-      }
+    protected void swap(final int index1, final int index2) {
+      Object tmp = elements[index1];
+      elements[index1] = elements[index2];
+      elements[index2] = tmp;
     }
   }
 
@@ -1499,8 +1519,24 @@ public Object newArray(Object old, int size, Schema schema) {
     } else if (old instanceof Collection) {
       ((Collection<?>) old).clear();
       return old;
-    } else
+    } else {
+      if (schema.getElementType().getType() == Type.INT) {
+        return new PrimitivesArrays.IntArray(size, schema);
+      }
+      if (schema.getElementType().getType() == Type.BOOLEAN) {
+        return new PrimitivesArrays.BooleanArray(size, schema);
+      }
+      if (schema.getElementType().getType() == Type.LONG) {
+        return new PrimitivesArrays.LongArray(size, schema);
+      }
+      if (schema.getElementType().getType() == Type.FLOAT) {
+        return new PrimitivesArrays.FloatArray(size, schema);
+      }
+      if (schema.getElementType().getType() == Type.DOUBLE) {
+        return new PrimitivesArrays.DoubleArray(size, schema);
+      }
       return new GenericData.Array<Object>(size, schema);
+    }
   }
 
   /**