Avoid unnecessary map instance creations on Presences

Author: skhugh

yorkie/src/main/kotlin/dev/yorkie/core/Presences.kt

@@ -5,30 +5,34 @@ import dev.yorkie.document.time.ActorID
 public typealias P = Map<String, String>
 
 public class Presences private constructor(
-    private val map: MutableMap<ActorID, MutableMap<String, String>>,
+    private val map: Map<ActorID, Map<String, String>>,
 ) : Map<ActorID, P> by map {
 
-    internal constructor() : this(mutableMapOf())
-
     public operator fun plus(presenceInfo: Pair<ActorID, P>): Presences {
         val (actorID, presence) = presenceInfo
         val newPresence = map[actorID].orEmpty() + presence
-        return (map + (actorID to newPresence)).asPresences()
+        return Presences(map + (actorID to newPresence))
     }
 
-    public operator fun minus(actorID: ActorID): Presences = (map - actorID).asPresences()
+    public operator fun minus(actorID: ActorID): Presences {
+        return Presences(map - actorID)
+    }
 
     override fun toString(): String {
         return map.entries.toString()
     }
 
     companion object {
         public fun Map<ActorID, P>.asPresences(): Presences {
-            return Presences(mapValues { it.value.toMutableMap() }.toMutableMap())
+            return if (this is Presences) {
+                Presences(map)
+            } else {
+                Presences(this)
+            }
         }
 
         public fun Pair<ActorID, P>.asPresences(): Presences {
-            return Presences(mutableMapOf(first to second.toMutableMap()))
+            return Presences(mapOf(this))
         }
 
         internal val UninitializedPresences = Presences(

yorkie/src/main/kotlin/dev/yorkie/document/Document.kt

@@ -111,7 +111,7 @@ public class Document(
     public val presences: StateFlow<Presences> =
         combine(_presences, onlineClients) { presences, onlineClients ->
             presences.filterKeys { it in onlineClients + changeID.actor }.asPresences()
-        }.stateIn(scope, SharingStarted.Eagerly, _presences.value.asPresences()).also {
+        }.stateIn(scope, SharingStarted.Eagerly, _presences.value).also {
             scope.launch {
                 it.collect { presences ->
                     presenceEventQueue.addAll(pendingPresenceEvents)