Array of Primitives: RealmObjectSchema support

CHANGELOG.md

@@ -16,6 +16,7 @@
 
 ## Enhancements
 
+* Added support for primitive lists in migrations using `RealmObjectSchema.addRealmListField(String name, Class<?> type)` (#5329).
 * Now users can use `String`, `byte[]`, `Boolean`, `Long`, `Integer`, `Short`, `Byte`, `Double`, `Float` and `Date` as a type parameter of `RealmList`.
 
 ## Bug Fixes

realm/realm-library/src/main/java/io/realm/DynamicRealmObject.java

@@ -17,6 +17,7 @@
 
 import java.util.Arrays;
 import java.util.Date;
+import java.util.Iterator;
 import java.util.Locale;
 
 import javax.annotation.Nonnull;
@@ -336,6 +337,8 @@ public DynamicRealmObject getObject(String fieldName) {
 
     /**
      * Returns the {@link RealmList} of {@link DynamicRealmObject}s being linked from the given field.
+     * <p>
+     * If the list contains primitive types, use {@link #getList(String, Class)} instead.
      *
      * @param fieldName the name of the field.
      * @return the {@link RealmList} data for this field.
@@ -346,7 +349,7 @@ public RealmList<DynamicRealmObject> getList(String fieldName) {
 
         long columnIndex = proxyState.getRow$realm().getColumnIndex(fieldName);
         try {
-            OsList osList = proxyState.getRow$realm().getList(columnIndex);
+            OsList osList = proxyState.getRow$realm().getModelList(columnIndex);
             //noinspection ConstantConditions
             @Nonnull
             String className = osList.getTargetTable().getClassName();
@@ -358,15 +361,54 @@ public RealmList<DynamicRealmObject> getList(String fieldName) {
     }
 
     /**
-     * Returns the {@link RealmList} of values being linked from the given field.
+     * Returns the {@link RealmList} containing only primitive values.
+     *
+     * <p>
+     * If the list contains references to other Realm objects, use {@link #getList(String)} instead.
      *
      * @param fieldName the name of the field.
+     * @param primitiveType the type of elements in the list. Only primitive types are supported.
      * @return the {@link RealmList} data for this field.
-     * @throws IllegalArgumentException if field name doesn't exist or it doesn't contain a list of values.
+     * @throws IllegalArgumentException if field name doesn't exist or it doesn't contain a list of primitive objects.
      */
-    public <T> RealmList<T> getValueList(String fieldName, Class<T> valueClass) {
-        // TODO implement this
-        return null;
+    public <E> RealmList<E> getList(String fieldName, Class<E> primitiveType) {
+        proxyState.getRealm$realm().checkIfValid();
+
+        if (primitiveType == null) {
+            throw new IllegalArgumentException("Non-null 'primitiveType' required.");
+        }
+        long columnIndex = proxyState.getRow$realm().getColumnIndex(fieldName);
+        RealmFieldType realmType = classToRealmType(primitiveType);
+        try {
+            OsList osList = proxyState.getRow$realm().getValueList(columnIndex, realmType);
+            return new RealmList<>(primitiveType, osList, proxyState.getRealm$realm());
+        } catch (IllegalArgumentException e) {
+            checkFieldType(fieldName, columnIndex, realmType);
+            throw e;
+        }
+    }
+
+    private <E> RealmFieldType classToRealmType(Class<E> primitiveType) {
+        if (primitiveType.equals(Integer.class)
+                || primitiveType.equals(Long.class)
+                || primitiveType.equals(Short.class)
+                || primitiveType.equals(Byte.class)) {
+            return RealmFieldType.INTEGER_LIST;
+        } else if (primitiveType.equals(Boolean.class)) {
+            return RealmFieldType.BOOLEAN_LIST;
+        } else if (primitiveType.equals(String.class)) {
+            return RealmFieldType.STRING_LIST;
+        } else if (primitiveType.equals(byte[].class)) {
+            return RealmFieldType.BINARY_LIST;
+        } else if (primitiveType.equals(Date.class)) {
+            return RealmFieldType.DATE_LIST;
+        } else if (primitiveType.equals(Float.class)) {
+            return RealmFieldType.FLOAT_LIST;
+        } else if (primitiveType.equals(Double.class)) {
+            return RealmFieldType.DOUBLE_LIST;
+        } else {
+            throw new IllegalArgumentException("Unsupported element type. Only primitive types supported. Yours was: " + primitiveType);
+        }
     }
 
     /**
@@ -393,6 +435,15 @@ public boolean isNull(String fieldName) {
             case DATE:
                 return proxyState.getRow$realm().isNull(columnIndex);
             case LIST:
+            case LINKING_OBJECTS:
+            case INTEGER_LIST:
+            case BOOLEAN_LIST:
+            case STRING_LIST:
+            case BINARY_LIST:
+            case DATE_LIST:
+            case FLOAT_LIST:
+            case DOUBLE_LIST:
+                // fall through
             default:
                 return false;
         }
@@ -510,28 +561,7 @@ private void setValue(String fieldName, Object value) {
             setObject(fieldName, (DynamicRealmObject) value);
         } else if (valueClass == RealmList.class) {
             RealmList<?> list = (RealmList<?>) value;
-            if (list.className == null && list.clazz == null) {
-                // unmanaged RealmList
-                long columnIndex = proxyState.getRow$realm().getColumnIndex(fieldName);
-                final RealmFieldType columnType = proxyState.getRow$realm().getColumnType(columnIndex);
-                if (columnType == RealmFieldType.LIST) {
-                    //noinspection unchecked
-                    for (Object element : list) {
-                        if (!(element instanceof RealmModel)) {
-                            throw new IllegalArgumentException("All elements in the list must be an instance of RealmModel.");
-                        }
-                    }
-                    //noinspection unchecked
-                    setList(fieldName, (RealmList<DynamicRealmObject>) list);
-                } else {
-                    setValueList(fieldName, list);
-                }
-            } else if (list.className != null || RealmModel.class.isAssignableFrom(list.clazz)) {
-                //noinspection unchecked
-                setList(fieldName, (RealmList<DynamicRealmObject>) list);
-            } else {
-                setValueList(fieldName, list);
-            }
+            setList(fieldName, list);
         } else {
             throw new IllegalArgumentException("Value is of an type not supported: " + value.getClass());
         }
@@ -727,21 +757,54 @@ public void setObject(String fieldName, @Nullable DynamicRealmObject value) {
      * Sets the reference to a {@link RealmList} on the given field.
      *
      * @param fieldName field name.
-     * @param list list of references.
-     * @throws IllegalArgumentException if field name doesn't exist, it is not a list field, the type
-     * of the object represented by the DynamicRealmObject doesn't match or any element in the list belongs to a
-     * different Realm.
+     * @param list list of objects. Must either be primitive types or {@link DynamicRealmObject}s.
+     * @throws IllegalArgumentException if field name doesn't exist, it is not a list field, the objects in the
+     * list doesn't match the expected type or any Realm object in the list belongs to a different Realm.
      */
-    public void setList(String fieldName, RealmList<DynamicRealmObject> list) {
+    public <E> void setList(String fieldName, RealmList<E> list) {
         proxyState.getRealm$realm().checkIfValid();
 
         //noinspection ConstantConditions
         if (list == null) {
-            throw new IllegalArgumentException("Null values not allowed for lists");
+            throw new IllegalArgumentException("Non-null 'list' required");
+        }
+
+        // Find type of list in Realm
+        long columnIndex = proxyState.getRow$realm().getColumnIndex(fieldName);
+        final RealmFieldType columnType = proxyState.getRow$realm().getColumnType(columnIndex);
+
+        switch (columnType) {
+            case LIST:
+                // Due to type erasure it is not possible to check the generic parameter,
+                // instead we try to see if the first element is of the wrong type in order
+                // to throw a better error message.
+                // Primitive types are checked inside `setModelList`
+                if (!list.isEmpty()) {
+                    E element = list.first();
+                    if (!(element instanceof DynamicRealmObject) && RealmModel.class.isAssignableFrom(element.getClass())) {
+                        throw new IllegalArgumentException("RealmList must contain `DynamicRealmObject's, not Java model classes.");
+                    }
+                }
+                //noinspection unchecked
+                setModelList(fieldName, (RealmList<DynamicRealmObject>) list);
+                break;
+            case INTEGER_LIST:
+            case BOOLEAN_LIST:
+            case STRING_LIST:
+            case BINARY_LIST:
+            case DATE_LIST:
+            case FLOAT_LIST:
+            case DOUBLE_LIST:
+                setValueList(fieldName, list, columnType);
+                break;
+            default:
+                throw new IllegalArgumentException(String.format("Field '%s' is not a list but a %s", fieldName, columnType));
         }
+    }
 
+    private void setModelList(String fieldName, RealmList<DynamicRealmObject> list) {
         long columnIndex = proxyState.getRow$realm().getColumnIndex(fieldName);
-        OsList osList = proxyState.getRow$realm().getList(columnIndex);
+        OsList osList = proxyState.getRow$realm().getModelList(columnIndex);
         Table linkTargetTable = osList.getTargetTable();
         //noinspection ConstantConditions
         @Nonnull
@@ -788,17 +851,72 @@ public void setList(String fieldName, RealmList<DynamicRealmObject> list) {
         }
     }
 
-    /**
-     * Sets the reference to a {@link RealmList} on the given field.
-     *
-     * @param fieldName field name.
-     * @param list list of references.
-     * @throws IllegalArgumentException if field name doesn't exist, it is not a list field, the type
-     * of the object represented by the DynamicRealmObject doesn't match or any element in the list belongs to a
-     * different Realm.
-     */
-    public void setValueList(String fieldName, RealmList<?> list) {
-        // TODO implement this
+    @SuppressWarnings("unchecked")
+    private <E> void setValueList(String fieldName, RealmList<E> list, RealmFieldType primitiveType) {
+        long columnIndex = proxyState.getRow$realm().getColumnIndex(fieldName);
+        OsList osList = proxyState.getRow$realm().getValueList(columnIndex, primitiveType);
+
+        Class<E> elementClass;
+        switch(primitiveType) {
+            case INTEGER_LIST: elementClass = (Class<E>) Long.class; break;
+            case BOOLEAN_LIST: elementClass = (Class<E>) Boolean.class; break;
+            case STRING_LIST: elementClass = (Class<E>) String.class; break;
+            case BINARY_LIST: elementClass = (Class<E>) byte[].class; break;
+            case DATE_LIST: elementClass = (Class<E>) Date.class; break;
+            case FLOAT_LIST: elementClass = (Class<E>) Float.class; break;
+            case DOUBLE_LIST: elementClass = (Class<E>) Double.class; break;
+            default:
+                throw new IllegalArgumentException("Unsupported type: " + primitiveType);
+        }
+        final ManagedListOperator<?> operator = getOperator(proxyState.getRealm$realm(), osList, primitiveType, elementClass);
+
+        if (list.isManaged() && osList.size() == list.size()) {
+            // There is a chance that the source list and the target list are the same list in the same object.
+            // In this case, we can't use removeAll().
+            final int size = list.size();
+            final Iterator<?> iterator = list.iterator();
+            for (int i = 0; i < size; i++) {
+                @Nullable
+                final Object value = iterator.next();
+                operator.set(i, value);
+            }
+        }  else {
+            osList.removeAll();
+            for (Object value : list) {
+                operator.append(value);
+            }
+        }
+    }
+
+    private <E> ManagedListOperator<E> getOperator(BaseRealm realm, OsList osList, RealmFieldType valueListType, Class<E> valueClass) {
+        if (valueListType == RealmFieldType.STRING_LIST) {
+            //noinspection unchecked
+            return (ManagedListOperator<E>) new StringListOperator(realm, osList, (Class<String>) valueClass);
+        }
+        if (valueListType == RealmFieldType.INTEGER_LIST) {
+            return new LongListOperator<>(realm, osList, valueClass);
+        }
+        if (valueListType == RealmFieldType.BOOLEAN_LIST) {
+            //noinspection unchecked
+            return (ManagedListOperator<E>) new BooleanListOperator(realm, osList, (Class<Boolean>) valueClass);
+        }
+        if (valueListType == RealmFieldType.BINARY_LIST) {
+            //noinspection unchecked
+            return (ManagedListOperator<E>) new BinaryListOperator(realm, osList, (Class<byte[]>) valueClass);
+        }
+        if (valueListType == RealmFieldType.DOUBLE_LIST) {
+            //noinspection unchecked
+            return (ManagedListOperator<E>) new DoubleListOperator(realm, osList, (Class<Double>) valueClass);
+        }
+        if (valueListType == RealmFieldType.FLOAT_LIST) {
+            //noinspection unchecked
+            return (ManagedListOperator<E>) new FloatListOperator(realm, osList, (Class<Float>) valueClass);
+        }
+        if (valueListType == RealmFieldType.DATE_LIST) {
+            //noinspection unchecked
+            return (ManagedListOperator<E>) new DateListOperator(realm, osList, (Class<Date>) valueClass);
+        }
+        throw new IllegalArgumentException("Unexpected list type: " + valueListType.name());
     }
 
     /**
@@ -964,7 +1082,28 @@ public String toString() {
                     break;
                 case LIST:
                     String targetClassName = proxyState.getRow$realm().getTable().getLinkTarget(columnIndex).getClassName();
-                    sb.append(String.format(Locale.US, "RealmList<%s>[%s]", targetClassName, proxyState.getRow$realm().getList(columnIndex).size()));
+                    sb.append(String.format(Locale.US, "RealmList<%s>[%s]", targetClassName, proxyState.getRow$realm().getModelList(columnIndex).size()));
+                    break;
+                case INTEGER_LIST:
+                    sb.append(String.format(Locale.US, "RealmList<Long>[%s]", proxyState.getRow$realm().getValueList(columnIndex, type).size()));
+                    break;
+                case BOOLEAN_LIST:
+                    sb.append(String.format(Locale.US, "RealmList<Boolean>[%s]", proxyState.getRow$realm().getValueList(columnIndex, type).size()));
+                    break;
+                case STRING_LIST:
+                    sb.append(String.format(Locale.US, "RealmList<String>[%s]", proxyState.getRow$realm().getValueList(columnIndex, type).size()));
+                    break;
+                case BINARY_LIST:
+                    sb.append(String.format(Locale.US, "RealmList<byte[]>[%s]", proxyState.getRow$realm().getValueList(columnIndex, type).size()));
+                    break;
+                case DATE_LIST:
+                    sb.append(String.format(Locale.US, "RealmList<Date>[%s]", proxyState.getRow$realm().getValueList(columnIndex, type).size()));
+                    break;
+                case FLOAT_LIST:
+                    sb.append(String.format(Locale.US, "RealmList<Float>[%s]", proxyState.getRow$realm().getValueList(columnIndex, type).size()));
+                    break;
+                case DOUBLE_LIST:
+                    sb.append(String.format(Locale.US, "RealmList<Double>[%s]", proxyState.getRow$realm().getValueList(columnIndex, type).size()));
                     break;
                 default:
                     sb.append("?");

realm/realm-library/src/main/java/io/realm/ImmutableRealmObjectSchema.java

@@ -55,6 +55,11 @@ public RealmObjectSchema addRealmListField(String fieldName, RealmObjectSchema o
         throw new UnsupportedOperationException(SCHEMA_IMMUTABLE_EXCEPTION_MSG);
     }
 
+    @Override
+    public RealmObjectSchema addRealmListField(String fieldName, Class<?> primitiveType) {
+        throw new UnsupportedOperationException(SCHEMA_IMMUTABLE_EXCEPTION_MSG);
+    }
+
     @Override
     public RealmObjectSchema removeField(String fieldName) {
         throw new UnsupportedOperationException(SCHEMA_IMMUTABLE_EXCEPTION_MSG);

realm/realm-library/src/main/java/io/realm/MutableRealmObjectSchema.java

@@ -19,7 +19,6 @@
 import java.util.Locale;
 
 import javax.annotation.Nonnull;
-import javax.annotation.Nullable;
 
 import io.realm.internal.OsObjectStore;
 import io.realm.internal.Table;
@@ -105,7 +104,7 @@ public RealmObjectSchema addField(String fieldName, Class<?> fieldType, FieldAtt
             nullable = false;
         }
 
-        long columnIndex = table.addColumn(metadata.realmType, fieldName, nullable);
+        long columnIndex = table.addColumn(metadata.fieldType, fieldName, nullable);
         try {
             addModifiers(fieldName, attributes);
         } catch (Exception e) {
@@ -132,6 +131,25 @@ public RealmObjectSchema addRealmListField(String fieldName, RealmObjectSchema o
         return this;
     }
 
+    @Override
+    public RealmObjectSchema addRealmListField(String fieldName, Class<?> primitiveType) {
+        checkLegalName(fieldName);
+        checkFieldNameIsAvailable(fieldName);
+
+        FieldMetaData metadata = SUPPORTED_SIMPLE_FIELDS.get(primitiveType);
+        if (metadata == null) {
+            if (primitiveType.equals(RealmObjectSchema.class) || RealmModel.class.isAssignableFrom(primitiveType)) {
+                throw new IllegalArgumentException("Use 'addRealmListField(String name, RealmObjectSchema schema)' instead to add lists that link to other RealmObjects: " + fieldName);
+            } else {
+                throw new IllegalArgumentException(String.format(Locale.US,
+                        "RealmList does not support lists with this type: %s(%s)",
+                        fieldName, primitiveType));
+            }
+        }
+        table.addColumn(metadata.listType, fieldName, metadata.defaultNullable);
+        return this;
+    }
+
     @Override
     public RealmObjectSchema removeField(String fieldName) {
         realm.checkNotInSync(); // destructive modification of a schema is not permitted

realm/realm-library/src/main/java/io/realm/MutableRealmSchema.java

@@ -64,12 +64,12 @@ public RealmObjectSchema createWithPrimaryKeyField(String className, String prim
         String internalTableName = checkAndGetTableNameFromClassName(className);
 
         RealmObjectSchema.FieldMetaData metadata = RealmObjectSchema.getSupportedSimpleFields().get(fieldType);
-        if (metadata == null || (metadata.realmType != RealmFieldType.STRING &&
-                metadata.realmType != RealmFieldType.INTEGER)) {
+        if (metadata == null || (metadata.fieldType != RealmFieldType.STRING &&
+                metadata.fieldType != RealmFieldType.INTEGER)) {
             throw new IllegalArgumentException(String.format("Realm doesn't support primary key field type '%s'.",
                     fieldType));
         }
-        boolean isStringField = (metadata.realmType == RealmFieldType.STRING);
+        boolean isStringField = (metadata.fieldType == RealmFieldType.STRING);
 
         boolean nullable = metadata.defaultNullable;
         if (MutableRealmObjectSchema.containsAttribute(attributes, FieldAttribute.REQUIRED)) {

realm/realm-library/src/main/java/io/realm/RealmList.java

@@ -70,7 +70,7 @@ public class RealmList<E> extends AbstractList<E> implements OrderedRealmCollect
     protected String className;
 
     // Always null if RealmList is unmanaged, always non-null if managed.
-    private final ManagedListOperator<E> osListOperator;
+    final ManagedListOperator<E> osListOperator;
     final protected BaseRealm realm;
     private List<E> unmanagedList;
     // Used for listeners on RealmList<RealmModel>