clarifiy APP_CONFIG deprecation note
[idea/community.git] / platform / core-api / src / com / intellij / openapi / util / AsyncResult.java
1 /*
2  * Copyright 2000-2016 JetBrains s.r.o.
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  * http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16 package com.intellij.openapi.util;
17
18 import com.intellij.openapi.diagnostic.Logger;
19 import com.intellij.util.Consumer;
20 import com.intellij.util.Function;
21 import com.intellij.util.PairConsumer;
22 import org.jetbrains.annotations.NotNull;
23 import org.jetbrains.annotations.Nullable;
24
25 public class AsyncResult<T> extends ActionCallback {
26   private static final Logger LOG = Logger.getInstance(AsyncResult.class);
27
28   protected T myResult;
29
30   public AsyncResult() {
31   }
32
33   AsyncResult(int countToDone, @Nullable T result) {
34     super(countToDone);
35
36     myResult = result;
37   }
38
39   @NotNull
40   public AsyncResult<T> setDone(T result) {
41     myResult = result;
42     setDone();
43     return this;
44   }
45
46   @NotNull
47   public AsyncResult<T> setRejected(T result) {
48     myResult = result;
49     setRejected();
50     return this;
51   }
52
53   @NotNull
54   public <DependentResult> AsyncResult<DependentResult> subResult(@NotNull Function<T, DependentResult> doneHandler) {
55     return subResult(new AsyncResult<DependentResult>(), doneHandler);
56   }
57
58   @NotNull
59   public <SubResult, SubAsyncResult extends AsyncResult<SubResult>> SubAsyncResult subResult(@NotNull SubAsyncResult subResult,
60                                                                                              @NotNull Function<T, SubResult> doneHandler) {
61     doWhenDone(new SubResultDoneCallback<T, SubResult, SubAsyncResult>(subResult, doneHandler)).notifyWhenRejected(subResult);
62     return subResult;
63   }
64
65   /**
66    * @deprecated Use {@link #doWhenDone(com.intellij.util.Consumer)} (to remove in IDEA 16)
67    */
68   @NotNull
69   @Deprecated
70   public AsyncResult<T> doWhenDone(@SuppressWarnings("deprecation") @NotNull final Handler<T> handler) {
71     doWhenDone(new Runnable() {
72       @Override
73       public void run() {
74         handler.run(myResult);
75       }
76     });
77     return this;
78   }
79
80   @NotNull
81   public AsyncResult<T> doWhenDone(@NotNull final Consumer<T> consumer) {
82     doWhenDone(new Runnable() {
83       @Override
84       public void run() {
85         consumer.consume(myResult);
86       }
87     });
88     return this;
89   }
90
91   @NotNull
92   public AsyncResult<T> doWhenRejected(@NotNull final PairConsumer<T, String> consumer) {
93     doWhenRejected(new Runnable() {
94       @Override
95       public void run() {
96         consumer.consume(myResult, myError);
97       }
98     });
99     return this;
100   }
101
102   @Override
103   @NotNull
104   public final AsyncResult<T> notify(@NotNull final ActionCallback child) {
105     super.notify(child);
106     return this;
107   }
108
109   public T getResult() {
110     return myResult;
111   }
112
113   public T getResultSync() {
114     return getResultSync(-1);
115   }
116
117   @Nullable
118   public T getResultSync(long msTimeout) {
119     waitFor(msTimeout);
120     return myResult;
121   }
122
123   @NotNull
124   public final ActionCallback doWhenProcessed(@NotNull final Consumer<T> consumer) {
125     doWhenDone(consumer);
126     doWhenRejected(new PairConsumer<T, String>() {
127       @Override
128       public void consume(T result, String error) {
129         consumer.consume(result);
130       }
131     });
132     return this;
133   }
134
135   /**
136    * @deprecated Use {@link com.intellij.util.Consumer} (to remove in IDEA 16)
137    */
138   @Deprecated
139   public interface Handler<T> {
140     void run(T t);
141   }
142
143   /**
144    * @deprecated Don't use AsyncResult - use Promise instead.
145    */
146   @Deprecated
147   public static class Done<T> extends AsyncResult<T> {
148     public Done(T value) {
149       setDone(value);
150     }
151   }
152
153   /**
154    * @deprecated Don't use AsyncResult - use Promise instead.
155    */
156   @Deprecated
157   public static class Rejected<T> extends AsyncResult<T> {
158     public Rejected() {
159       setRejected();
160     }
161
162     public Rejected(T value) {
163       setRejected(value);
164     }
165   }
166
167   /**
168    * @deprecated Don't use AsyncResult - use Promise instead.
169    */
170   @NotNull
171   @Deprecated
172   public static <R> AsyncResult<R> rejected() {
173     //noinspection unchecked,deprecation
174     return new Rejected();
175   }
176
177   /**
178    * @deprecated Don't use AsyncResult - use Promise instead.
179    */
180   @NotNull
181   @Deprecated
182   public static <R> AsyncResult<R> rejected(@NotNull String errorMessage) {
183     AsyncResult<R> result = new AsyncResult<R>();
184     result.reject(errorMessage);
185     return result;
186   }
187
188   @NotNull
189   public static <R> AsyncResult<R> done(@Nullable R result) {
190     return new AsyncResult<R>().setDone(result);
191   }
192
193   // we don't use inner class, avoid memory leak, we don't want to hold this result while dependent is computing
194   private static class SubResultDoneCallback<Result, SubResult, AsyncSubResult extends AsyncResult<SubResult>> implements Consumer<Result> {
195     private final AsyncSubResult subResult;
196     private final Function<Result, SubResult> doneHandler;
197
198     public SubResultDoneCallback(AsyncSubResult subResult, Function<Result, SubResult> doneHandler) {
199       this.subResult = subResult;
200       this.doneHandler = doneHandler;
201     }
202
203     @Override
204     public void consume(Result result) {
205       SubResult v;
206       try {
207         v = doneHandler.fun(result);
208       }
209       catch (Throwable e) {
210         subResult.reject(e.getMessage());
211         LOG.error(e);
212         return;
213       }
214       subResult.setDone(v);
215     }
216   }
217 }