Consistent equals method for collection types

packages/cinterop/src/commonMain/kotlin/io/realm/kotlin/internal/interop/RealmInterop.kt

@@ -317,6 +317,7 @@ expect object RealmInterop {
     fun realm_get_backlinks(obj: RealmObjectPointer, sourceClassKey: ClassKey, sourcePropertyKey: PropertyKey): RealmResultsPointer
     fun realm_list_size(list: RealmListPointer): Long
     fun MemAllocator.realm_list_get(list: RealmListPointer, index: Long): RealmValue
+    fun realm_list_find(list: RealmListPointer, value: RealmValue): Long
     fun realm_list_get_list(list: RealmListPointer, index: Long): RealmListPointer
     fun realm_list_get_dictionary(list: RealmListPointer, index: Long): RealmMapPointer
     fun realm_list_add(list: RealmListPointer, index: Long, transport: RealmValue)

packages/cinterop/src/jvm/kotlin/io/realm/kotlin/internal/interop/RealmInterop.kt

@@ -568,6 +568,18 @@ actual object RealmInterop {
         realmc.realm_list_get(list.cptr(), index, struct)
         return RealmValue(struct)
     }
+
+    actual fun realm_list_find(list: RealmListPointer, value: RealmValue): Long {
+        val index = LongArray(1)
+        val found = BooleanArray(1)
+        realmc.realm_list_find(list.cptr(), value.value, index, found)
+        return if (found[0]) {
+            index[0]
+        } else {
+            -1
+        }
+    }
+
     actual fun realm_list_get_list(list: RealmListPointer, index: Long): RealmListPointer =
         LongPointerWrapper(realmc.realm_list_get_list(list.cptr(), index))
 

packages/cinterop/src/nativeDarwin/kotlin/io/realm/kotlin/internal/interop/RealmInterop.kt

@@ -1038,6 +1038,19 @@ actual object RealmInterop {
         return RealmValue(struct)
     }
 
+    actual fun realm_list_find(list: RealmListPointer, value: RealmValue): Long {
+        memScoped {
+            val index = alloc<ULongVar>()
+            val found = alloc<BooleanVar>()
+            checkedBooleanResult(realm_wrapper.realm_list_find(list.cptr(), value.value.readValue(), index.ptr, found.ptr))
+            return if (found.value) {
+                index.value.toLong()
+            } else {
+                -1
+            }
+        }
+    }
+
     actual fun realm_list_get_list(list: RealmListPointer, index: Long): RealmListPointer =
         CPointerWrapper(realm_wrapper.realm_list_get_list(list.cptr(), index.toULong()))
 

packages/library-base/src/commonMain/kotlin/io/realm/kotlin/internal/RealmListInternal.kt

@@ -20,6 +20,7 @@
 import io.realm.kotlin.Versioned
 import io.realm.kotlin.dynamic.DynamicRealmObject
 import io.realm.kotlin.ext.asRealmObject
+import io.realm.kotlin.ext.isManaged
 import io.realm.kotlin.internal.RealmValueArgumentConverter.convertToQueryArgs
 import io.realm.kotlin.internal.interop.Callback
 import io.realm.kotlin.internal.interop.ClassKey
@@ -64,10 +65,8 @@
     }
 
     override fun toString(): String = "UnmanagedRealmList{${joinToString()}}"
 
-    override fun equals(other: Any?): Boolean = backingList == other
 
-    override fun hashCode(): Int = backingList.hashCode()
 }
 
 /**
@@ -90,10 +89,23 @@
         return operator.get(index)
     }
 
+    override fun contains(element: E): Boolean {
+        return operator.contains(element)
+    }
+
+    override fun indexOf(element: E): Int {
+        return operator.indexOf(element)
+    }
+
+
     override fun add(index: Int, element: E) {
         operator.insert(index, element)
     }
 
+    override fun remove(element: E): Boolean {
+        return operator.remove(element)
+    }
+
     // We need explicit overrides of these to ensure that we capture duplicate references to the
     // same unmanaged object in our internal import caching mechanism
     override fun addAll(elements: Collection<E>): Boolean = operator.insertAll(size, elements)
@@ -156,6 +168,19 @@
         !nativePointer.isReleased() && RealmInterop.realm_list_is_valid(nativePointer)
 
     override fun delete() = RealmInterop.realm_list_remove_all(nativePointer)
+
+    override fun equals(other: Any?): Boolean {
+        val o = other as? ManagedRealmList<*>
+        return when (o) {
+            null -> false
+            else -> RealmInterop.realm_equals(nativePointer, o.nativePointer)
+        }
+    }
+
+    override fun hashCode(): Int {
+        // TODO Improve distribution. Maybe something like parent.table + parent.ref + parent.key + version
+        return operator.realmReference.version().version.hashCode()
+    }
 }
 
 internal class RealmListChangeFlow<E>(producerScope: ProducerScope<ListChange<E>>) :
@@ -225,6 +250,10 @@
 
     fun get(index: Int): E
 
+    fun contains(element: E): Boolean = indexOf(element) != -1
+
+    fun indexOf(element: E): Int
+
     // TODO OPTIMIZE We technically don't need update policy and cache for primitive lists but right now RealmObjectHelper.assign doesn't know how to differentiate the calls to the operator
     fun insert(
         index: Int,
@@ -233,6 +262,14 @@
         cache: UnmanagedToManagedObjectCache = mutableMapOf()
     )
 
+    fun remove(element: E): Boolean = when (val index = indexOf(element)) {
+        -1 -> false
+        else -> {
+            RealmInterop.realm_list_erase(nativePointer, index.toLong())
+            true
+        }
+    }
+
     fun insertAll(
         index: Int,
         elements: Collection<E>,
@@ -277,6 +314,14 @@
         }
     }
 
+    override fun indexOf(element: E): Int {
+        inputScope {
+            with(realmValueConverter) {
+                return RealmInterop.realm_list_find(nativePointer, publicToRealmValue(element)).toInt()
+            }
+        }
+    }
+
     override fun insert(
         index: Int,
         element: E,
@@ -296,7 +341,7 @@
         index: Int,
         element: E,
         updatePolicy: UpdatePolicy,
-        cache: UnmanagedToManagedObjectCache
+        cache: UnmanagedToManagedObjectCache,
     ): E {
         return get(index).also {
             inputScope {
@@ -310,7 +355,7 @@
 
     override fun copy(
         realmReference: RealmReference,
-        nativePointer: RealmListPointer
+        nativePointer: RealmListPointer,
     ): ListOperator<E> =
         PrimitiveListOperator(mediator, realmReference, realmValueConverter, nativePointer)
 }
@@ -354,6 +399,17 @@
         }
     }
 
+    override fun indexOf(element: RealmAny?): Int {
+        // Unmanaged objects are never found in a managed collections
+        if (element?.type == RealmAny.Type.OBJECT) {
+            if (!element.asRealmObject<RealmObjectInternal>().isManaged()) return -1
+        }
+        return inputScope {
+            val transport = realmAnyToRealmValueWithoutImport(element)
+            RealmInterop.realm_list_find(nativePointer, transport).toInt()
+        }
+    }
+
     override fun insert(
         index: Int,
         element: RealmAny?,
@@ -461,6 +517,18 @@
             realmValueToRealmObject(transport, clazz, mediator, realmReference) as E
         }
     }
+
+    override fun indexOf(element: E): Int {
+        // Unmanaged objects are never found in a managed collections
+        element?.also {
+            if (!(it as RealmObjectInternal).isManaged()) return -1
+        }
+        return inputScope {
+            val objRef = realmObjectToRealmReferenceOrError(element as BaseRealmObject?)
+            val transport = realmObjectTransport(objRef as RealmObjectInterop)
+            RealmInterop.realm_list_find(nativePointer, transport).toInt()
+        }
+    }
 }
 
 internal class RealmObjectListOperator<E : BaseRealmObject?>(

packages/library-base/src/commonMain/kotlin/io/realm/kotlin/internal/RealmMapInternal.kt

@@ -768,19 +768,7 @@
 
     override fun toString(): String = entries.joinToString { (key, value) -> "[$key,$value]" }
         .let { "UnmanagedRealmDictionary{$it}" }
 
-    override fun equals(other: Any?): Boolean {
-        if (other !is RealmDictionary<*>) return false
-        if (this === other) return true
-        if (this.size == other.size && this.entries.containsAll(other.entries)) return true
-        return false
-    }
-
-    override fun hashCode(): Int {
-        var result = size.hashCode()
-        result = 31 * result + entries.hashCode()
-        return result
-    }
 }
 
 internal class ManagedRealmDictionary<V> constructor(
@@ -819,7 +807,18 @@
         return "RealmDictionary{size=$size,owner=$owner,objKey=$objKey,version=$version}"
     }
 
-    // TODO add equals and hashCode when https://github.com/realm/realm-kotlin/issues/1097 is fixed
+    override fun equals(other: Any?): Boolean {
+        val o = other as? ManagedRealmMap<*, *>
+        return when (o) {
+            null -> false
+            else -> RealmInterop.realm_equals(nativePointer, o.nativePointer)
+        }
+    }
+
+    override fun hashCode(): Int {
+        // TODO Improve distribution. Maybe something like parent.table + parent.ref + parent.key + version
+        return operator.realmReference.version().version.hashCode()
+    }
 }
 
 internal class RealmDictonaryChangeFlow<V>(scope: ProducerScope<MapChange<String, V>>) :

packages/library-base/src/commonMain/kotlin/io/realm/kotlin/internal/RealmObjectHelper.kt

@@ -1235,14 +1235,15 @@ internal object RealmObjectHelper {
         if (other == null || obj::class != other::class) return false
 
         other as BaseRealmObject
-
-        if (other.isManaged()) {
-            if (obj.isValid() != other.isValid()) return false
-            return obj.getIdentifierOrNull() == other.getIdentifierOrNull()
+        return if (obj.isManaged() && other.isManaged()) {
+            RealmInterop.realm_equals(
+                obj.realmObjectReference!!.objectPointer,
+                other.realmObjectReference!!.objectPointer
+            )
         } else {
             // If one of the objects are unmanaged, they are only equal if identical, which
             // should have been caught at the top of this function.
-            return false
+            false
         }
     }
 

packages/library-base/src/commonMain/kotlin/io/realm/kotlin/internal/RealmSetInternal.kt

@@ -66,10 +66,8 @@
     }
 
     override fun toString(): String = "UnmanagedRealmSet{${joinToString()}}"
 
-    override fun equals(other: Any?): Boolean = backingSet == other
 
-    override fun hashCode(): Int = backingSet.hashCode()
 }
 
 /**
@@ -205,6 +203,19 @@
     override fun isValid(): Boolean {
         return !nativePointer.isReleased() && RealmInterop.realm_set_is_valid(nativePointer)
     }
+
+    override fun equals(other: Any?): Boolean {
+        val o = other as? ManagedRealmSet<*>
+        return when (o) {
+            null -> false
+            else -> RealmInterop.realm_equals(nativePointer, o.nativePointer)
+        }
+    }
+
+    override fun hashCode(): Int {
+        // TODO Improve distribution. Maybe something like parent.table + parent.ref + parent.key + version
+        return operator.realmReference.version().version.hashCode()
+    }
 }
 
 internal fun <E : BaseRealmObject> ManagedRealmSet<E>.query(
@@ -345,8 +356,8 @@
                 transport, null, mediator, realmReference,
                 issueDynamicObject,
                 issueDynamicMutableObject,
-                { error("Set should never container lists") }
-            ) { error("Set should never container dictionaries") }
+                { error("Set should never contain lists") }
+            ) { error("Set should never contain dictionaries") }
         }
     }
 

packages/test-base/src/commonTest/kotlin/io/realm/kotlin/test/common/RealmAnyNestedCollectionTests.kt

@@ -573,6 +573,9 @@
         realm.query<JsonStyleRealmObject>("value[*] == 4").find().single().run {
             assertEquals("LIST", id)
         }
+        realm.query<JsonStyleRealmObject>("value[*] == {4, 5, 6}").find().single().run {
+            assertEquals("LIST", id)
+        }
 
         // Matching dictionaries
         realm.query<JsonStyleRealmObject>("value.key1 == 7").find().single().run {
@@ -606,5 +609,11 @@
         realm.query<JsonStyleRealmObject>("value[*].key3[0] == 9").find().single().run {
             assertEquals("EMBEDDED", id)
         }
+        realm.query<JsonStyleRealmObject>("value[0][*] == {4, 5, 6}").find().single().run {
+            assertEquals("EMBEDDED", id)
+        }
+        realm.query<JsonStyleRealmObject>("value[*][*] == {4, 5, 6}").find().single().run {
+            assertEquals("EMBEDDED", id)
+        }
     }
 }

packages/test-base/src/commonTest/kotlin/io/realm/kotlin/test/common/RealmAnyTests.kt

@@ -26,6 +26,7 @@ import io.realm.kotlin.entities.embedded.EmbeddedParent
 import io.realm.kotlin.entities.embedded.embeddedSchema
 import io.realm.kotlin.ext.asRealmObject
 import io.realm.kotlin.ext.query
+import io.realm.kotlin.ext.realmAnyListOf
 import io.realm.kotlin.ext.realmDictionaryOf
 import io.realm.kotlin.ext.realmListOf
 import io.realm.kotlin.ext.realmSetOf
@@ -489,9 +490,18 @@ class RealmAnyTests {
                     // Different objects of same type are not equal
                     assertNotEquals(RealmAny.create(Sample()), RealmAny.create(realmObject))
                 }
-                // Collections in RealmAny are tested in RealmAnyNestedCollections.kt
-                RealmAny.Type.LIST,
-                RealmAny.Type.DICTIONARY -> {}
+                RealmAny.Type.LIST -> {
+                    val value = realmAnyListOf(1, "String", Sample())
+                    // Lists are only comparing equal on referential equality
+                    assertNotEquals(value, realmAnyListOf(1, "String", Sample()))
+                    assertEquals(value, value)
+                }
+                RealmAny.Type.DICTIONARY -> {
+                    val value = realmDictionaryOf("key1" to "String", "key2" to Sample())
+                    // Lists are only comparing equal on referential equality
+                    assertNotEquals(value, realmDictionaryOf("key1" to "String", "key2" to Sample()))
+                    assertEquals(value, value)
+                }
             }
         }
     }