From 0f9b9ed2452dc8e3bfa5cdf9b21657d3be875d26 Mon Sep 17 00:00:00 2001 From: Andrey Breslav Date: Thu, 21 Nov 2013 14:21:55 +0400 Subject: [PATCH] StorageManager rewritten to Kotlin --- .../jet/storage/LockBasedStorageManager.java | 38 ++++++++-------- ...{StorageManager.java => StorageManager.kt} | 43 ++++++------------- 2 files changed, 31 insertions(+), 50 deletions(-) rename core/util.runtime/src/org/jetbrains/jet/storage/{StorageManager.java => StorageManager.kt} (52%) diff --git a/core/util.runtime/src/org/jetbrains/jet/storage/LockBasedStorageManager.java b/core/util.runtime/src/org/jetbrains/jet/storage/LockBasedStorageManager.java index e769820d046..9796e136c7a 100644 --- a/core/util.runtime/src/org/jetbrains/jet/storage/LockBasedStorageManager.java +++ b/core/util.runtime/src/org/jetbrains/jet/storage/LockBasedStorageManager.java @@ -56,13 +56,13 @@ public class LockBasedStorageManager implements StorageManager { @NotNull @Override - public MemoizedFunctionToNotNull createMemoizedFunction(@NotNull Function1 compute) { + public MemoizedFunctionToNotNull createMemoizedFunction(@NotNull Function1 compute) { return createMemoizedFunction(compute, new ConcurrentHashMap()); } @NotNull protected MemoizedFunctionToNotNull createMemoizedFunction( - @NotNull Function1 compute, + @NotNull Function1 compute, @NotNull ConcurrentMap map ) { return new MapBasedMemoizedFunctionToNotNull(map, compute); @@ -70,13 +70,13 @@ public class LockBasedStorageManager implements StorageManager { @NotNull @Override - public MemoizedFunctionToNullable createMemoizedFunctionWithNullableValues(@NotNull Function1 compute) { + public MemoizedFunctionToNullable createMemoizedFunctionWithNullableValues(@NotNull Function1 compute) { return createMemoizedFunctionWithNullableValues(compute, new ConcurrentHashMap()); } @NotNull protected MemoizedFunctionToNullable createMemoizedFunctionWithNullableValues( - @NotNull Function1 compute, + @NotNull Function1 compute, @NotNull ConcurrentMap map ) { return new MapBasedMemoizedFunction(map, compute); @@ -84,14 +84,14 @@ public class LockBasedStorageManager implements StorageManager { @NotNull @Override - public NotNullLazyValue createLazyValue(@NotNull Function0 computable) { + public NotNullLazyValue createLazyValue(@NotNull Function0 computable) { return new LockBasedNotNullLazyValue(computable); } @NotNull @Override public NotNullLazyValue createRecursionTolerantLazyValue( - @NotNull Function0 computable, @NotNull final T onRecursiveCall + @NotNull Function0 computable, @NotNull final T onRecursiveCall ) { return new LockBasedNotNullLazyValue(computable) { @NotNull @@ -105,9 +105,9 @@ public class LockBasedStorageManager implements StorageManager { @NotNull @Override public NotNullLazyValue createLazyValueWithPostCompute( - @NotNull Function0 computable, - final Function1 onRecursiveCall, - @NotNull final Function1 postCompute + @NotNull Function0 computable, + final Function1 onRecursiveCall, + @NotNull final Function1 postCompute ) { return new LockBasedNotNullLazyValue(computable) { @NotNull @@ -128,13 +128,13 @@ public class LockBasedStorageManager implements StorageManager { @NotNull @Override - public NullableLazyValue createNullableLazyValue(@NotNull Function0 computable) { + public NullableLazyValue createNullableLazyValue(@NotNull Function0 computable) { return new LockBasedLazyValue(computable); } @NotNull @Override - public NullableLazyValue createRecursionTolerantNullableLazyValue(@NotNull Function0 computable, final T onRecursiveCall) { + public NullableLazyValue createRecursionTolerantNullableLazyValue(@NotNull Function0 computable, final T onRecursiveCall) { return new LockBasedLazyValue(computable) { @NotNull @Override @@ -147,7 +147,7 @@ public class LockBasedStorageManager implements StorageManager { @NotNull @Override public NullableLazyValue createNullableLazyValueWithPostCompute( - @NotNull Function0 computable, @NotNull final Function1 postCompute + @NotNull Function0 computable, @NotNull final Function1 postCompute ) { return new LockBasedLazyValue(computable) { @Override @@ -158,7 +158,7 @@ public class LockBasedStorageManager implements StorageManager { } @Override - public T compute(@NotNull Function0 computable) { + public T compute(@NotNull Function0 computable) { lock.lock(); try { return computable.invoke(); @@ -216,12 +216,12 @@ public class LockBasedStorageManager implements StorageManager { private class LockBasedLazyValue implements NullableLazyValue { - private final Function0 computable; + private final Function0 computable; @Nullable private volatile Object value = NotValue.NOT_COMPUTED; - public LockBasedLazyValue(@NotNull Function0 computable) { + public LockBasedLazyValue(@NotNull Function0 computable) { this.computable = computable; } @@ -291,7 +291,7 @@ public class LockBasedStorageManager implements StorageManager { private class LockBasedNotNullLazyValue extends LockBasedLazyValue implements NotNullLazyValue { - public LockBasedNotNullLazyValue(@NotNull Function0 computable) { + public LockBasedNotNullLazyValue(@NotNull Function0 computable) { super(computable); } @@ -306,9 +306,9 @@ public class LockBasedStorageManager implements StorageManager { private class MapBasedMemoizedFunction implements MemoizedFunctionToNullable { private final ConcurrentMap cache; - private final Function1 compute; + private final Function1 compute; - public MapBasedMemoizedFunction(@NotNull ConcurrentMap map, @NotNull Function1 compute) { + public MapBasedMemoizedFunction(@NotNull ConcurrentMap map, @NotNull Function1 compute) { this.cache = map; this.compute = compute; } @@ -361,7 +361,7 @@ public class LockBasedStorageManager implements StorageManager { public MapBasedMemoizedFunctionToNotNull( @NotNull ConcurrentMap map, - @NotNull Function1 compute + @NotNull Function1 compute ) { super(map, compute); } diff --git a/core/util.runtime/src/org/jetbrains/jet/storage/StorageManager.java b/core/util.runtime/src/org/jetbrains/jet/storage/StorageManager.kt similarity index 52% rename from core/util.runtime/src/org/jetbrains/jet/storage/StorageManager.java rename to core/util.runtime/src/org/jetbrains/jet/storage/StorageManager.kt index b0bcedd123d..9a93217e413 100644 --- a/core/util.runtime/src/org/jetbrains/jet/storage/StorageManager.java +++ b/core/util.runtime/src/org/jetbrains/jet/storage/StorageManager.kt @@ -14,16 +14,10 @@ * limitations under the License. */ -package org.jetbrains.jet.storage; +package org.jetbrains.jet.storage -import jet.Function0; -import jet.Function1; -import jet.Unit; -import jet.runtime.typeinfo.KotlinSignature; -import org.jetbrains.annotations.NotNull; -import org.jetbrains.annotations.Nullable; -public interface StorageManager { +public trait StorageManager { /** * Given a function compute: K -> V create a memoized version of it that computes a value only once for each key * @param compute the function to be memoized @@ -32,18 +26,13 @@ public interface StorageManager { * NOTE: if compute() has side-effects the WEAK reference kind is dangerous: the side-effects will be repeated if * the value gets collected and then re-computed */ - @NotNull - MemoizedFunctionToNotNull createMemoizedFunction(@NotNull Function1 compute); - @KotlinSignature( - "fun createMemoizedFunctionWithNullableValues(compute: (K) -> V?): MemoizedFunctionToNullable") - @NotNull - MemoizedFunctionToNullable createMemoizedFunctionWithNullableValues(@NotNull Function1 compute); + fun createMemoizedFunction(compute: (K) -> V): MemoizedFunctionToNotNull - @NotNull - NotNullLazyValue createLazyValue(@NotNull Function0 computable); + fun createMemoizedFunctionWithNullableValues(compute: (K) -> V?): MemoizedFunctionToNullable - @NotNull - NotNullLazyValue createRecursionTolerantLazyValue(@NotNull Function0 computable, @NotNull T onRecursiveCall); + fun createLazyValue(computable: () -> T): NotNullLazyValue + + fun createRecursionTolerantLazyValue(computable: () -> T, onRecursiveCall: T): NotNullLazyValue /** * @param onRecursiveCall is called if the computation calls itself recursively. @@ -52,25 +41,17 @@ public interface StorageManager { * otherwise it's executed and its result is returned * @param postCompute is called after the value is computed, but before any other thread sees it */ - @NotNull - NotNullLazyValue createLazyValueWithPostCompute( - @NotNull Function0 computable, - @Nullable Function1 onRecursiveCall, - @NotNull Function1 postCompute - ); + fun createLazyValueWithPostCompute(computable: () -> T, onRecursiveCall: ((Boolean) -> T)?, postCompute: (T) -> Unit): NotNullLazyValue - @NotNull - NullableLazyValue createNullableLazyValue(@NotNull Function0 computable); + fun createNullableLazyValue(computable: () -> T?): NullableLazyValue - @NotNull - NullableLazyValue createRecursionTolerantNullableLazyValue(@NotNull Function0 computable, @Nullable T onRecursiveCall); + fun createRecursionTolerantNullableLazyValue(computable: () -> T?, onRecursiveCall: T?): NullableLazyValue /** * {@code postCompute} is called after the value is computed, but before any other thread sees it (the current thread may * see it in between) */ - @NotNull - NullableLazyValue createNullableLazyValueWithPostCompute(@NotNull Function0 computable, @NotNull Function1 postCompute); + fun createNullableLazyValueWithPostCompute(computable: () -> T?, postCompute: (T?) -> Unit): NullableLazyValue - T compute(@NotNull Function0 computable); + fun compute(computable: () -> T): T }