org.jetbrains.jet.lang.resolve.lazy.storage
Interface StorageManager

All Known Implementing Classes:

LockBasedStorageManager

public interface StorageManager

Nested Class Summary

static class

StorageManager.ReferenceKind

Method Summary

<T> NotNullLazyValue<T>	createLazyValue(com.intellij.openapi.util.Computable<T> computable)
<T> NotNullLazyValue<T>	createLazyValueWithPostCompute(com.intellij.openapi.util.Computable<T> computable, com.intellij.util.Consumer<T> postCompute) postCompute is called after the value is computed, but before any other thread sees it (the current thread may see it in between)
<K,V> MemoizedFunctionToNotNull<K,V>	createMemoizedFunction(com.intellij.util.Function<K,V> compute, StorageManager.ReferenceKind valuesReferenceKind) Given a function compute: K -> V create a memoized version of it that computes a value only once for each key
<K,V> MemoizedFunctionToNullable<K,V>	createMemoizedFunctionWithNullableValues(com.intellij.util.Function<K,V> compute, StorageManager.ReferenceKind valuesReferenceKind)
<T> NullableLazyValue<T>	createNullableLazyValue(com.intellij.openapi.util.Computable<T> computable)
<T> NullableLazyValue<T>	createNullableLazyValueWithPostCompute(com.intellij.openapi.util.Computable<T> computable, com.intellij.util.Consumer<T> postCompute) postCompute is called after the value is computed, but before any other thread sees it (the current thread may see it in between)
BindingTrace	createSafeTrace(BindingTrace originalTrace)

Method Detail

createMemoizedFunction

@NotNull
<K,V> MemoizedFunctionToNotNull<K,V> createMemoizedFunction(@NotNull
                                                                    com.intellij.util.Function<K,V> compute,
                                                                    @NotNull
                                                                    StorageManager.ReferenceKind valuesReferenceKind)

Given a function compute: K -> V create a memoized version of it that computes a value only once for each key

Parameters:

compute - the function to be memoized

valuesReferenceKind - how to store the memoized values 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

createMemoizedFunctionWithNullableValues

@NotNull
<K,V> MemoizedFunctionToNullable<K,V> createMemoizedFunctionWithNullableValues(@NotNull
                                                                                       com.intellij.util.Function<K,V> compute,
                                                                                       @NotNull
                                                                                       StorageManager.ReferenceKind valuesReferenceKind)

createLazyValue

@NotNull
<T> NotNullLazyValue<T> createLazyValue(@NotNull
                                                com.intellij.openapi.util.Computable<T> computable)

createLazyValueWithPostCompute

@NotNull
<T> NotNullLazyValue<T> createLazyValueWithPostCompute(@NotNull
                                                               com.intellij.openapi.util.Computable<T> computable,
                                                               @NotNull
                                                               com.intellij.util.Consumer<T> postCompute)

postCompute is called after the value is computed, but before any other thread sees it (the current thread may see it in between)

createNullableLazyValue

@NotNull
<T> NullableLazyValue<T> createNullableLazyValue(@NotNull
                                                         com.intellij.openapi.util.Computable<T> computable)

createNullableLazyValueWithPostCompute

@NotNull
<T> NullableLazyValue<T> createNullableLazyValueWithPostCompute(@NotNull
                                                                        com.intellij.openapi.util.Computable<T> computable,
                                                                        @NotNull
                                                                        com.intellij.util.Consumer<T> postCompute)

postCompute is called after the value is computed, but before any other thread sees it (the current thread may see it in between)

createSafeTrace

@NotNull
BindingTrace createSafeTrace(@NotNull
                                     BindingTrace originalTrace)