change name of concurrentGetOrPutSlightlyUnsafe to concurrentGetOrPut…

…Proxy, and prepare to override it for JDK 8 module to be safe.
kohesive · Aug 11, 2015 · 9951615 · 9951615
1 parent 6584acd
commit 9951615
Show file tree

Hide file tree

Showing 2 changed files with 5 additions and 5 deletions.
diff --git a/core/src/main/kotlin/uy/kohesive/injekt/registry/default/ConcurrentGetOrPut.kt b/core/src/main/kotlin/uy/kohesive/injekt/registry/default/ConcurrentGetOrPut.kt
@@ -4,7 +4,7 @@ import java.util.concurrent.ConcurrentMap
 
 // TODO: this is not perfect, the factory could be called more than once if two threads race to initialize a value
 //       JDK 8 has a real version of ConcurrentMap.computeIfAbsent
-public inline fun <K,V> ConcurrentMap<K, V>.concurrentGetOrPutSlightlyUnsafe(key: K, defaultValue: ()-> V) : V {
+public inline fun <K,V> ConcurrentMap<K, V>.concurrentGetOrPutProxy(key: K, defaultValue: ()-> V) : V {
     var answer = this.get(key)
     if (answer == null) {
         answer = defaultValue()

diff --git a/core/src/main/kotlin/uy/kohesive/injekt/registry/default/DefaultRegistrar.kt b/core/src/main/kotlin/uy/kohesive/injekt/registry/default/DefaultRegistrar.kt
@@ -53,7 +53,7 @@ public open class DefaultRegistrar : InjektRegistrar {
     }
 
     override fun <R> addSingletonFactory(forClass: Class<R>, factoryCalledOnce: () -> R) {
-        factories.put(forClass, { existingValues.concurrentGetOrPutSlightlyUnsafe(Instance(forClass, NOKEY), { factoryCalledOnce() }) })
+        factories.put(forClass, { existingValues.concurrentGetOrPutProxy(Instance(forClass, NOKEY), { factoryCalledOnce() }) })
     }
 
     override fun <R> addFactory(forClass: Class<R>, factoryCalledEveryTime: () -> R) {
@@ -62,23 +62,23 @@ public open class DefaultRegistrar : InjektRegistrar {
 
     override fun <R> addPerThreadFactory(forClass: Class<R>, factoryCalledOncePerThread: () -> R) {
         factories.put(forClass, {
-            existingValues.concurrentGetOrPutSlightlyUnsafe(Instance(forClass, ThreadKey(Thread.currentThread(), NOKEY)), { factoryCalledOncePerThread() })
+            existingValues.concurrentGetOrPutProxy(Instance(forClass, ThreadKey(Thread.currentThread(), NOKEY)), { factoryCalledOncePerThread() })
         })
     }
 
     @suppress("UNCHECKED_CAST")
     override fun <R, K> addPerKeyFactory(forClass: Class<R>, forKeyClass: Class<K>, factoryCalledPerKey: (K) -> R) {
         keyedFactories.put(forClass, {
             key ->
-            existingValues.concurrentGetOrPutSlightlyUnsafe(Instance(forClass, key), { factoryCalledPerKey(key as K) })
+            existingValues.concurrentGetOrPutProxy(Instance(forClass, key), { factoryCalledPerKey(key as K) })
         })
     }
 
     @suppress("UNCHECKED_CAST")
     override fun <R, K> addPerThreadPerKeyFactory(forClass: Class<R>, forKeyClass: Class<K>, factoryCalledPerKeyPerThread: (K) -> R) {
         keyedFactories.put(forClass, {
             key ->
-            existingValues.concurrentGetOrPutSlightlyUnsafe(Instance(forClass, ThreadKey(Thread.currentThread(), key)), { factoryCalledPerKeyPerThread(key as K) })
+            existingValues.concurrentGetOrPutProxy(Instance(forClass, ThreadKey(Thread.currentThread(), key)), { factoryCalledPerKeyPerThread(key as K) })
         })
     }