ProcessingContext: fix javadoc formatting
[idea/community.git] / platform / util / src / com / intellij / util / ProcessingContext.java
1 // Copyright 2000-2020 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license that can be found in the LICENSE file.
2 package com.intellij.util;
3
4 import com.intellij.openapi.util.Key;
5 import org.jetbrains.annotations.NonNls;
6 import org.jetbrains.annotations.NotNull;
7
8 import java.util.HashMap;
9 import java.util.Map;
10
11 /**
12  * A wrapper around map, allowing to put and get values by keys in a type-safe way. Used in various extension implementations
13  * to manage temporary state. For example:
14  * <ul>
15  * <li>When creating {@code ElementPattern}, processing context may be used to cache some intermediate data
16  * to be shared between pattern parts.</li>
17  * <li>Some extensions (e.g, {@code PsiReferenceProvider}, {@code CompletionContributors}) use per-pattern registration. That allows to use
18  * {@code ElementPattern#save} to put matched objects into processing contexts and then retrieve those objects inside extension implementation
19  * after the matching is complete.</li>
20  * </ul>
21  * 
22  * Simple processing context can contain a shared processing context inside, which should be used when iterating over several patterns 
23  * or extensions, possibly from different plugins. They may still wish to reuse some cached information that a previous extension has already calculated.
24  * <p>
25  * In this case, a separate ProcessingContext object is created for each of those extensions, but the same {@link SharedProcessingContext}
26  * is passed to their constructors. To reuse shared context, extensions are required to work with {@link #getSharedContext()} result.
27  * </p>
28  * Not thread-safe.
29  *
30  * @see #get(Key) 
31  * @see #put(Key, Object)
32  * @see #ProcessingContext(SharedProcessingContext) 
33  * @author peter
34  */
35 public class ProcessingContext {
36   private Map<Object, Object> myMap;
37   private SharedProcessingContext mySharedContext;
38
39   public ProcessingContext() {
40   }
41
42   public ProcessingContext(final SharedProcessingContext sharedContext) {
43     mySharedContext = sharedContext;
44   }
45
46   @NotNull
47   public SharedProcessingContext getSharedContext() {
48     if (mySharedContext == null) {
49       return mySharedContext = new SharedProcessingContext();
50     }
51     return mySharedContext;
52   }
53
54   public Object get(@NotNull @NonNls final Object key) {
55     return myMap == null? null : myMap.get(key);
56   }
57
58   public void put(@NotNull @NonNls final Object key, @NotNull final Object value) {
59     checkMapInitialized();
60     myMap.put(key, value);
61   }
62
63   public <T> void put(Key<T> key, T value) {
64     checkMapInitialized();
65     myMap.put(key, value);
66   }
67
68   public <T> T get(Key<T> key) {
69     return myMap == null ? null : (T)myMap.get(key);
70   }
71
72   private void checkMapInitialized() {
73     if (myMap == null) myMap = new HashMap<>(1);
74   }
75
76 }