Dicts - dynamic realms (#7471)

clementetb · web-flow · commit 8f83a97e1c89 · 2021-05-19T23:39:28.000+02:00
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -5,6 +5,7 @@
 
 ### Enhancements
 * Allow `insert` and `insertOrUpdate` operations on `RealmObject` or `RealmObject` collections containing `RealmDictionary` or `RealmSet` fields.
+* Added support for `RealmDictionary` in `DynamicRealmObject` with `setDictionary(String fieldName, RealmDictionary<?> dictionary)`, `getDictionary(String fieldName, Class<?> primitiveType)`, and `getDictionary(String fieldName)`.
 
 ### Fixed
 * Removed wrong `@Nullable` annotation on `RealmQuery.maxRealmAny()`.
diff --git a/realm/realm-library/src/androidTest/kotlin/io/realm/DictionaryTester.kt b/realm/realm-library/src/androidTest/kotlin/io/realm/DictionaryTester.kt
@@ -39,6 +39,7 @@ interface DictionaryTester : GenericTester {
     fun values()
     fun entrySet()
     fun freeze()
+    fun dynamic()
     fun insert()
     fun insertList()
     fun insertOrUpdate()
diff --git a/realm/realm-library/src/androidTest/kotlin/io/realm/ManagedDictionaryTesters.kt b/realm/realm-library/src/androidTest/kotlin/io/realm/ManagedDictionaryTesters.kt
diff --git a/realm/realm-library/src/androidTest/kotlin/io/realm/ParameterizedDictionaryTests.kt b/realm/realm-library/src/androidTest/kotlin/io/realm/ParameterizedDictionaryTests.kt
@@ -169,6 +169,11 @@ class ParameterizedDictionaryTests(
         tester.freeze()
     }
 
+    @Test
+    fun dynamic() {
+        tester.dynamic()
+    }
+
     @Test
     fun insert() {
         tester.insert()
diff --git a/realm/realm-library/src/androidTest/kotlin/io/realm/UnmanagedDictionaryTesters.kt b/realm/realm-library/src/androidTest/kotlin/io/realm/UnmanagedDictionaryTesters.kt
@@ -209,6 +209,7 @@ class UnmanagedDictionaryTester<T : Any>(
         }
     }
 
+    override fun dynamic() = Unit                                           // Not applicable
     override fun insert() = Unit                                            // Not applicable
     override fun insertList() = Unit                                        // Not applicable
     override fun insertOrUpdate() = Unit                                    // Not applicable
diff --git a/realm/realm-library/src/androidTest/kotlin/io/realm/entities/DictionaryAllTypes.java b/realm/realm-library/src/androidTest/kotlin/io/realm/entities/DictionaryAllTypes.java
@@ -30,6 +30,7 @@
 
 public class DictionaryAllTypes extends RealmObject {
 
+    public static final String NAME = "DictionaryAllTypes";
     public static final String FIELD_STRING_DICTIONARY = "columnStringDictionary";
 
     private RealmDictionary<DogPrimaryKey> columnRealmDictionary;
diff --git a/realm/realm-library/src/main/java/io/realm/DynamicRealmObject.java b/realm/realm-library/src/main/java/io/realm/DynamicRealmObject.java
diff --git a/realm/realm-library/src/main/java/io/realm/ManagedMapManager.java b/realm/realm-library/src/main/java/io/realm/ManagedMapManager.java
@@ -194,6 +194,14 @@ boolean isNotNullItemTypeValid(@Nullable Object item, Class<?> clazz) {
     OsMap getOsMap() {
         return mapValueOperator.osMap;
     }
+
+    String getClassName() {
+        return typeSelectorForMap.getValueClassName();
+    }
+
+    Class<V> getValueClass() {
+        return typeSelectorForMap.getValueClass();
+    }
 }
 
 /**
diff --git a/realm/realm-library/src/main/java/io/realm/RealmDictionary.java b/realm/realm-library/src/main/java/io/realm/RealmDictionary.java
@@ -82,6 +82,17 @@ public RealmDictionary(Map<String, V> map) {
         super(getStrategy(valueClass, baseRealm, osMap));
     }
 
+    /**
+     * Constructor used by {@code DynamicRealmObject}s.
+     *
+     * @param baseRealm
+     * @param osMap
+     * @param className
+     */
+    RealmDictionary(BaseRealm baseRealm, OsMap osMap, String className) {
+        super(getStrategy(className, baseRealm, osMap));
+    }
+
     // ------------------------------------------
     // Private stuff
     // ------------------------------------------
@@ -118,7 +129,6 @@ private static <V> ManagedMapStrategy<String, V> getStrategy(Class<V> valueClass
         return new ManagedMapStrategy<>(manager);
     }
 
-    @SuppressFBWarnings(value = "UPM_UNCALLED_PRIVATE_METHOD", justification = "This function would be used on dynamic realms, not yet implemented")
     private static <V> ManagedMapStrategy<String, V> getStrategy(String valueClass,
                                                                  BaseRealm baseRealm,
                                                                  OsMap osMap) {
@@ -175,44 +185,41 @@ private static <V> DictionaryManager<V> getManager(Class<V> valueClass,
     private static <V> DictionaryManager<V> getManager(String valueClass,
                                                        BaseRealm baseRealm,
                                                        OsMap osMap) {
-        TypeSelectorForMap<String, V> typeSelectorForMap = new DynamicSelectorForMap<>(baseRealm, osMap, valueClass);
 
         MapValueOperator<String, ?> mapValueOperator;
 
         if (valueClass.equals(RealmAny.class.getCanonicalName())) {
-            mapValueOperator = new RealmAnyValueOperator<>(baseRealm, osMap, (TypeSelectorForMap<String, RealmAny>) typeSelectorForMap);
+            mapValueOperator = new RealmAnyValueOperator<>(baseRealm, osMap, new SelectorForMap<>(baseRealm, osMap, String.class, RealmAny.class));
         } else if (valueClass.equals(Long.class.getCanonicalName())) {
-            mapValueOperator = new GenericPrimitiveValueOperator<>(Long.class, baseRealm, osMap, (TypeSelectorForMap<String, Long>) typeSelectorForMap, RealmMapEntrySet.IteratorType.LONG);
+            mapValueOperator = new GenericPrimitiveValueOperator<>(Long.class, baseRealm, osMap, new SelectorForMap<>(baseRealm, osMap, String.class, Long.class), RealmMapEntrySet.IteratorType.LONG);
         } else if (valueClass.equals(Float.class.getCanonicalName())) {
-            mapValueOperator = new GenericPrimitiveValueOperator<>(Float.class, baseRealm, osMap, (TypeSelectorForMap<String, Float>) typeSelectorForMap, RealmMapEntrySet.IteratorType.FLOAT);
+            mapValueOperator = new GenericPrimitiveValueOperator<>(Float.class, baseRealm, osMap, new SelectorForMap<>(baseRealm, osMap, String.class, Float.class), RealmMapEntrySet.IteratorType.FLOAT);
         } else if (valueClass.equals(Double.class.getCanonicalName())) {
-            mapValueOperator = new GenericPrimitiveValueOperator<>(Double.class, baseRealm, osMap, (TypeSelectorForMap<String, Double>) typeSelectorForMap, RealmMapEntrySet.IteratorType.DOUBLE);
+            mapValueOperator = new GenericPrimitiveValueOperator<>(Double.class, baseRealm, osMap, new SelectorForMap<>(baseRealm, osMap, String.class, Double.class), RealmMapEntrySet.IteratorType.DOUBLE);
         } else if (valueClass.equals(String.class.getCanonicalName())) {
-            mapValueOperator = new GenericPrimitiveValueOperator<>(String.class, baseRealm, osMap, (TypeSelectorForMap<String, String>) typeSelectorForMap, RealmMapEntrySet.IteratorType.STRING);
+            mapValueOperator = new GenericPrimitiveValueOperator<>(String.class, baseRealm, osMap, new SelectorForMap<>(baseRealm, osMap, String.class, String.class), RealmMapEntrySet.IteratorType.STRING);
         } else if (valueClass.equals(Boolean.class.getCanonicalName())) {
-            mapValueOperator = new GenericPrimitiveValueOperator<>(Boolean.class, baseRealm, osMap, (TypeSelectorForMap<String, Boolean>) typeSelectorForMap, RealmMapEntrySet.IteratorType.BOOLEAN);
+            mapValueOperator = new GenericPrimitiveValueOperator<>(Boolean.class, baseRealm, osMap, new SelectorForMap<>(baseRealm, osMap, String.class, Boolean.class), RealmMapEntrySet.IteratorType.BOOLEAN);
         } else if (valueClass.equals(Date.class.getCanonicalName())) {
-            mapValueOperator = new GenericPrimitiveValueOperator<>(Date.class, baseRealm, osMap, (TypeSelectorForMap<String, Date>) typeSelectorForMap, RealmMapEntrySet.IteratorType.DATE);
+            mapValueOperator = new GenericPrimitiveValueOperator<>(Date.class, baseRealm, osMap, new SelectorForMap<>(baseRealm, osMap, String.class, Date.class), RealmMapEntrySet.IteratorType.DATE);
         } else if (valueClass.equals(Decimal128.class.getCanonicalName())) {
-            mapValueOperator = new GenericPrimitiveValueOperator<>(Decimal128.class, baseRealm, osMap, (TypeSelectorForMap<String, Decimal128>) typeSelectorForMap, RealmMapEntrySet.IteratorType.DECIMAL128);
+            mapValueOperator = new GenericPrimitiveValueOperator<>(Decimal128.class, baseRealm, osMap, new SelectorForMap<>(baseRealm, osMap, String.class, Decimal128.class), RealmMapEntrySet.IteratorType.DECIMAL128);
         } else if (valueClass.equals(Integer.class.getCanonicalName())) {
-            mapValueOperator = new IntegerValueOperator<>(baseRealm, osMap, (TypeSelectorForMap<String, Integer>) typeSelectorForMap);
+            mapValueOperator = new IntegerValueOperator<>(baseRealm, osMap, new SelectorForMap<>(baseRealm, osMap, String.class, Integer.class));
         } else if (valueClass.equals(Short.class.getCanonicalName())) {
-            mapValueOperator = new ShortValueOperator<>(baseRealm, osMap, (TypeSelectorForMap<String, Short>) typeSelectorForMap);
+            mapValueOperator = new ShortValueOperator<>(baseRealm, osMap, new SelectorForMap<>(baseRealm, osMap, String.class, Short.class));
         } else if (valueClass.equals(Byte.class.getCanonicalName())) {
-            mapValueOperator = new ByteValueOperator<>(baseRealm, osMap, (TypeSelectorForMap<String, Byte>) typeSelectorForMap);
+            mapValueOperator = new ByteValueOperator<>(baseRealm, osMap, new SelectorForMap<>(baseRealm, osMap, String.class, Byte.class));
         } else if (valueClass.equals(byte[].class.getCanonicalName())) {
-            mapValueOperator = new GenericPrimitiveValueOperator<>((Class<V>) byte[].class, baseRealm, osMap, typeSelectorForMap, RealmMapEntrySet.IteratorType.BINARY, (EqualsHelper<String, V>) new BinaryEquals<String>());
+            mapValueOperator = new GenericPrimitiveValueOperator<>(byte[].class, baseRealm, osMap, new SelectorForMap<>(baseRealm, osMap, String.class, byte[].class), RealmMapEntrySet.IteratorType.BINARY, (EqualsHelper<String, byte[]>) new BinaryEquals<String>());
         } else if (valueClass.equals(ObjectId.class.getCanonicalName())) {
-            mapValueOperator = new GenericPrimitiveValueOperator<>(ObjectId.class, baseRealm, osMap, (TypeSelectorForMap<String, ObjectId>) typeSelectorForMap, RealmMapEntrySet.IteratorType.OBJECT_ID);
+            mapValueOperator = new GenericPrimitiveValueOperator<>(ObjectId.class, baseRealm, osMap,  new SelectorForMap<>(baseRealm, osMap, String.class, ObjectId.class), RealmMapEntrySet.IteratorType.OBJECT_ID);
         } else if (valueClass.equals(UUID.class.getCanonicalName())) {
-            mapValueOperator = new GenericPrimitiveValueOperator<>(UUID.class, baseRealm, osMap, (TypeSelectorForMap<String, UUID>) typeSelectorForMap, RealmMapEntrySet.IteratorType.UUID);
+            mapValueOperator = new GenericPrimitiveValueOperator<>(UUID.class, baseRealm, osMap,  new SelectorForMap<>(baseRealm, osMap, String.class, UUID.class), RealmMapEntrySet.IteratorType.UUID);
         } else {
-            throw new IllegalArgumentException("Only Maps of RealmAny or one of the types that can be boxed inside RealmAny can be used.");
+            mapValueOperator = new RealmModelValueOperator<>(baseRealm, osMap, new DynamicSelectorForMap<>(baseRealm, osMap, valueClass));
         }
 
-        return new DictionaryManager<>(baseRealm,
-                (MapValueOperator<String, V>) mapValueOperator,
-                typeSelectorForMap);
+        return new DictionaryManager<>(baseRealm, (MapValueOperator<String, V>) mapValueOperator, (TypeSelectorForMap<String, V>) mapValueOperator.typeSelectorForMap);
     }
 }
diff --git a/realm/realm-library/src/main/java/io/realm/RealmMap.java b/realm/realm-library/src/main/java/io/realm/RealmMap.java
@@ -305,6 +305,14 @@ OsMap getOsMap() {
         return mapStrategy.getOsMap();
     }
 
+    String getValueClassName() {
+        return mapStrategy.getValueClassName();
+    }
+
+    Class<V> getValueClass() {
+        return mapStrategy.getValueClass();
+    }
+
     /**
      * Strategy responsible for abstracting the managed/unmanaged logic for maps.
      *
@@ -340,6 +348,10 @@ abstract static class MapStrategy<K, V> implements Map<K, V>, ManageableObject,
 
         abstract OsMap getOsMap();
 
+        abstract String getValueClassName();
+
+        abstract Class<V> getValueClass();
+
         // ------------------------------------------
         // Map API
         // ------------------------------------------
@@ -514,6 +526,16 @@ protected boolean hasListeners() {
         OsMap getOsMap() {
             return managedMapManager.getOsMap();
         }
+
+        @Override
+        String getValueClassName() {
+            return managedMapManager.getClassName();
+        }
+
+        @Override
+        Class<V> getValueClass() {
+            return managedMapManager.getValueClass();
+        }
     }
 
     /**
@@ -658,5 +680,15 @@ protected boolean hasListeners() {
         OsMap getOsMap() {
             throw new UnsupportedOperationException("Unmanaged maps aren't represented in native code.");
         }
+
+        @Override
+        String getValueClassName() {
+            throw new UnsupportedOperationException("Unmanaged maps do not support retrieving the value class name.");
+        }
+
+        @Override
+        Class<V> getValueClass() {
+            throw new UnsupportedOperationException("Unmanaged maps do not support retrieving the value class.");
+        }
     }
 }
diff --git a/realm/realm-library/src/main/java/io/realm/TypeSelectorForMap.java b/realm/realm-library/src/main/java/io/realm/TypeSelectorForMap.java
@@ -68,6 +68,10 @@ protected Map.Entry<K, V> getModelEntry(BaseRealm baseRealm, long objRow, K key)
     abstract Collection<V> getValues();
 
     abstract RealmDictionary<V> freeze(BaseRealm frozenBaseRealm);
+
+    abstract String getValueClassName();
+
+    abstract Class<V> getValueClass();
 }
 
 /**
@@ -107,18 +111,20 @@ public RealmDictionary<V> freeze(BaseRealm frozenBaseRealm) {
     private <T> RealmResults<T> produceResults(BaseRealm baseRealm,
                                                Pair<Table, Long> tableAndValuesPtr,
                                                boolean forPrimitives,
-                                               @Nullable Class<T> clazz) {
-        if (baseRealm instanceof Realm) {
-            Realm realm = (Realm) baseRealm;
-            Long valuesPtr = tableAndValuesPtr.second;
-            OsResults osResults = OsResults.createFromMap(baseRealm.sharedRealm, valuesPtr);
-            if (clazz != null) {
-                return new RealmResults<>(realm, osResults, clazz, forPrimitives);
-            }
-            throw new IllegalStateException("MapValueOperator missing class.");
-        }
+                                               Class<T> clazz) {
+        Long valuesPtr = tableAndValuesPtr.second;
+        OsResults osResults = OsResults.createFromMap(baseRealm.sharedRealm, valuesPtr);
+        return new RealmResults<>(baseRealm, osResults, clazz, forPrimitives);
+    }
 
-        throw new UnsupportedOperationException("Add support for 'values' for DynamicRealms.");
+    @Override
+    Class<V> getValueClass() {
+        return valueClass;
+    }
+
+    @Override
+    String getValueClassName() {
+        return valueClass.getSimpleName();
     }
 }
 
@@ -171,7 +177,7 @@ public Map.Entry<K, V> getModelEntry(BaseRealm baseRealm, long objRow, K key) {
 /**
  * Implementation for DynamicRealms.
  */
-class DynamicSelectorForMap<K, V> extends TypeSelectorForMap<K, V> {
+class DynamicSelectorForMap<K> extends TypeSelectorForMap<K, DynamicRealmObject> {
 
     private final String className;
 
@@ -183,38 +189,72 @@ class DynamicSelectorForMap<K, V> extends TypeSelectorForMap<K, V> {
     }
 
     @Override
-    public V getRealmModel(BaseRealm baseRealm, long realmModelKey) {
-        // TODO
-        throw new UnsupportedOperationException("Support for getRealmModel for DynamicRealms not ready yet ");
+    public DynamicRealmObject getRealmModel(BaseRealm baseRealm, long realmModelKey) {
+        return baseRealm.get(DynamicRealmObject.class, className, realmModelKey);
     }
 
     @Override
-    public V putRealmModel(BaseRealm baseRealm, OsMap osMap, K key, @Nullable V value) {
-        // TODO
-        throw new UnsupportedOperationException("Support for putRealmModel for DynamicRealms not ready yet ");
+    public DynamicRealmObject putRealmModel(BaseRealm baseRealm, OsMap osMap, K key, @Nullable DynamicRealmObject value) {
+        long rowModelKey = osMap.getModelRowKey(key);
+
+        if (value == null) {
+            osMap.put(key, null);
+        } else {
+            boolean isEmbedded = baseRealm.getSchema().getSchemaForClass(className).isEmbedded();
+            if (isEmbedded) {
+                long objKey = osMap.createAndPutEmbeddedObject(key);
+                CollectionUtils.updateEmbeddedObject((Realm) baseRealm, value, objKey);
+            } else {
+                boolean copyObject = CollectionUtils.checkCanObjectBeCopied(baseRealm, value, className, DICTIONARY_TYPE);
+                RealmObjectProxy proxy = (RealmObjectProxy) ((copyObject) ? CollectionUtils.copyToRealm(baseRealm, value) : value);
+                osMap.putRow(key, proxy.realmGet$proxyState().getRow$realm().getObjectKey());
+            }
+        }
+
+        if (rowModelKey == OsMap.NOT_FOUND) {
+            return null;
+        } else {
+            return baseRealm.get(DynamicRealmObject.class, className, rowModelKey);
+        }
+    }
+
+    // Do not use <K> or <V> as this method can be used for either keys or values
+    private <T> RealmResults<T> produceResults(BaseRealm baseRealm,
+            Pair<Table, Long> tableAndValuesPtr,
+            String className) {
+        Long valuesPtr = tableAndValuesPtr.second;
+        OsResults osResults = OsResults.createFromMap(baseRealm.sharedRealm, valuesPtr);
+        return new RealmResults<>(baseRealm, osResults, className, false);
     }
 
     @Override
-    public Map.Entry<K, V> getModelEntry(BaseRealm baseRealm, long objRow, K key) {
-        // TODO
-        throw new UnsupportedOperationException("Support for getModelEntry for DynamicRealms not ready yet ");
+    public Map.Entry<K, DynamicRealmObject> getModelEntry(BaseRealm baseRealm, long objRow, K key) {
+        DynamicRealmObject realmModel = baseRealm.get(DynamicRealmObject.class, className, objRow);
+        return new AbstractMap.SimpleImmutableEntry<>(key, realmModel);
     }
 
     @Override
     public Set<K> keySet() {
-        // TODO
-        throw new UnsupportedOperationException("Support for keySet for DynamicRealms not ready yet ");
+        return new HashSet<>(produceResults(baseRealm, osMap.tableAndKeyPtrs(), className));
     }
 
     @Override
-    public Collection<V> getValues() {
-        // TODO
-        throw new UnsupportedOperationException("Support for getValues for DynamicRealms not ready yet ");
+    public Collection<DynamicRealmObject> getValues() {
+        return produceResults(baseRealm, osMap.tableAndValuePtrs(), className);
     }
 
     @Override
-    public RealmDictionary<V> freeze(BaseRealm frozenBaseRealm) {
-        // TODO
-        throw new UnsupportedOperationException("Support for freeze for DynamicRealms not ready yet ");
+    public RealmDictionary<DynamicRealmObject> freeze(BaseRealm frozenBaseRealm) {
+        return new RealmDictionary<>(frozenBaseRealm, osMap, className);
+    }
+
+    @Override
+    Class<DynamicRealmObject> getValueClass() {
+        return DynamicRealmObject.class;
+    }
+
+    @Override
+    String getValueClassName() {
+        return className;
     }
 }
diff --git a/realm/realm-library/src/main/java/io/realm/internal/CheckedRow.java b/realm/realm-library/src/main/java/io/realm/internal/CheckedRow.java
@@ -133,7 +133,7 @@ public OsMap getRealmAnyMap(long columnIndex) {
     @Override
     public OsMap getModelMap(long columnIndex) {
         RealmFieldType fieldType = getTable().getColumnType(columnIndex);
-        if (fieldType != RealmFieldType.STRING_TO_MIXED_MAP) {
+        if (fieldType != RealmFieldType.STRING_TO_LINK_MAP) {
             throw new IllegalArgumentException(
                     String.format(Locale.US, "Field '%s' is not a 'RealmDictionary'.",
                             getTable().getColumnName(columnIndex)));
diff --git a/realm/realm-library/src/main/java/io/realm/internal/OsMap.java b/realm/realm-library/src/main/java/io/realm/internal/OsMap.java
@@ -62,6 +62,10 @@ private OsMap(OsSharedRealm osSharedRealm, long nativePtr, Table targetTable) {
         context.addReference(this);
     }
 
+    public Table getTargetTable() {
+        return targetTable;
+    }
+
     @Override
     public long getNativePtr() {
         return nativePtr;
diff --git a/realm/realm-library/src/testUtils/java/io/realm/entities/DogPrimaryKey.java b/realm/realm-library/src/testUtils/java/io/realm/entities/DogPrimaryKey.java
@@ -27,6 +27,7 @@ public class DogPrimaryKey extends RealmObject {
     public static final String CLASS_NAME = "DogPrimaryKey";
     public static final String AGE = "age";
     public static final String BIRTHDAY = "birthday";
+    public static final String ID = "id";
 
     @PrimaryKey
     private long id;

Original file line number	Diff line number	Diff line change
`@@ -209,6 +209,7 @@ class UnmanagedDictionaryTester<T : Any>(`
`209`	`209`	`}`
`210`	`210`	`}`
`211`	`211`
	`212`	`+ override fun dynamic() = Unit // Not applicable`
`212`	`213`	`override fun insert() = Unit // Not applicable`
`213`	`214`	`override fun insertList() = Unit // Not applicable`
`214`	`215`	`override fun insertOrUpdate() = Unit // Not applicable`
Original file line number	Diff line number	Diff line change
`@@ -194,6 +194,14 @@ boolean isNotNullItemTypeValid(@Nullable Object item, Class<?> clazz) {`
`194`	`194`	`OsMap getOsMap() {`
`195`	`195`	`return mapValueOperator.osMap;`
`196`	`196`	`}`
	`197`	`+`
	`198`	`+ String getClassName() {`
	`199`	`+ return typeSelectorForMap.getValueClassName();`
	`200`	`+ }`
	`201`	`+`
	`202`	`+ Class<V> getValueClass() {`
	`203`	`+ return typeSelectorForMap.getValueClass();`
	`204`	`+ }`
`197`	`205`	`}`
`198`	`206`
`199`	`207`	`/**`