StorageManager (Kotlin Compiler)

All Known Implementing Classes:

LockBasedStorageManager
```
public interface StorageManager
```

Nested Class Summary

Nested Classes
Modifier and Type Interface and Description

static class StorageManager.ReferenceKind

Nested Classes
Modifier and Type	Interface and Description
`static class`	`StorageManager.ReferenceKind`

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)`

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)