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

Class LockBasedStorageManager

java.lang.Object

org.jetbrains.jet.lang.resolve.lazy.storage.LockBasedStorageManager

All Implemented Interfaces:

StorageManager

public class LockBasedStorageManager
extends java.lang.Object
implements StorageManager

Nested Class Summary

Nested classes/interfaces inherited from interface org.jetbrains.jet.lang.resolve.lazy.storage.StorageManager

StorageManager.ReferenceKind

Constructor Summary

Constructors

Constructor and Description
LockBasedStorageManager()

Method Summary

Methods

Modifier and Type	Method and Description
<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)

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Detail

LockBasedStorageManager

public LockBasedStorageManager()

Method Detail

createMemoizedFunction

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

Description copied from interface: StorageManager

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

Specified by:

createMemoizedFunction in interface StorageManager

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
public <K,V> MemoizedFunctionToNullable<K,V> createMemoizedFunctionWithNullableValues(@NotNull
                                                                                     com.intellij.util.Function<K,V> compute,
                                                                                     @NotNull
                                                                                     StorageManager.ReferenceKind valuesReferenceKind)

Specified by:

createMemoizedFunctionWithNullableValues in interface StorageManager

createLazyValue

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

Specified by:

createLazyValue in interface StorageManager

createLazyValueWithPostCompute

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

Description copied from interface: StorageManager

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

Specified by:

createLazyValueWithPostCompute in interface StorageManager

createNullableLazyValue

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

Specified by:

createNullableLazyValue in interface StorageManager

createNullableLazyValueWithPostCompute

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

Description copied from interface: StorageManager

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

Specified by:

createNullableLazyValueWithPostCompute in interface StorageManager

createSafeTrace

@NotNull
public BindingTrace createSafeTrace(@NotNull
                                   BindingTrace originalTrace)

Specified by:

createSafeTrace in interface StorageManager