Moves LocalCache's Synchronized block to Concurrent implementations

app/src/main/java/com/vitorpamplona/amethyst/model/LocalCache.kt

@@ -5,7 +5,6 @@ import androidx.compose.runtime.Stable
 import com.vitorpamplona.amethyst.Amethyst
 import com.vitorpamplona.amethyst.service.checkNotInMainThread
 import com.vitorpamplona.amethyst.service.model.*
-import com.vitorpamplona.amethyst.service.model.ATag.Companion.isATag
 import com.vitorpamplona.amethyst.service.nip19.Nip19
 import com.vitorpamplona.amethyst.service.relays.Relay
 import com.vitorpamplona.amethyst.ui.components.BundledInsert
@@ -42,14 +41,12 @@ object LocalCache {
         return null
     }
 
-    @Synchronized
     fun getOrCreateUser(key: HexKey): User {
         // checkNotInMainThread()
 
         return users[key] ?: run {
-            val answer = User(key)
+            val newObject = User(key)
-            users.put(key, answer)
+            users.putIfAbsent(key, newObject) ?: newObject
-            answer
         }
     }
 
@@ -84,14 +81,13 @@ object LocalCache {
         return null
     }
 
-    @Synchronized
     fun getOrCreateNote(idHex: String): Note {
         checkNotInMainThread()
 
-        return notes[idHex] ?: run {
+        return notes.get(idHex) ?: run {
-            val answer = Note(idHex)
+            val newObject = Note(idHex)
-            notes.put(idHex, answer)
+            notes.putIfAbsent(idHex, newObject) ?: newObject
-            answer
+            newObject
         }
     }
 
@@ -124,14 +120,12 @@ object LocalCache {
         }
     }
 
-    @Synchronized
     fun getOrCreateChannel(key: String, channelFactory: (String) -> Channel): Channel {
         checkNotInMainThread()
 
         return channels[key] ?: run {
-            val answer = channelFactory(key)
+            val newObject = channelFactory(key)
-            channels.put(key, answer)
+            channels.putIfAbsent(key, newObject) ?: newObject
-            answer
         }
     }
 
@@ -149,16 +143,14 @@ object LocalCache {
         }
     }
 
-    @Synchronized
     fun getOrCreateAddressableNoteInternal(key: ATag): AddressableNote {
         checkNotInMainThread()
 
         // we can't use naddr here because naddr might include relay info and
         // the preferred relay should not be part of the index.
         return addressables[key.toTag()] ?: run {
-            val answer = AddressableNote(key)
+            val newObject = AddressableNote(key)
-            addressables.put(key.toTag(), answer)
+            addressables.putIfAbsent(key.toTag(), newObject) ?: newObject
-            answer
         }
     }
 
@@ -547,8 +539,7 @@ object LocalCache {
 
         // Log.d("PM", "${author.toBestDisplayName()} to ${recipient?.toBestDisplayName()}")
 
-        val repliesTo = event.tags.filter { it.firstOrNull() == "e" }.mapNotNull { it.getOrNull(1) }
+        val repliesTo = event.taggedEvents().mapNotNull { checkGetOrCreateNote(it) }
-            .mapNotNull { checkGetOrCreateNote(it) }
 
         note.loadEvent(event, author, repliesTo)