[duplicates] enable duplicates analysis in PyCharm/WebStorm/PhpStorm/RubyMine
[idea/community.git] / platform / core-api / src / org / jetbrains / concurrency / DonePromise.java
1 // Copyright 2000-2018 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 org.jetbrains.concurrency;
3
4 import com.intellij.util.Function;
5 import org.jetbrains.annotations.NotNull;
6 import org.jetbrains.annotations.Nullable;
7 import org.jetbrains.concurrency.InternalPromiseUtil.PromiseValue;
8
9 import java.util.concurrent.ExecutionException;
10 import java.util.concurrent.TimeUnit;
11 import java.util.concurrent.TimeoutException;
12 import java.util.function.Consumer;
13
14 import static org.jetbrains.concurrency.InternalPromiseUtil.CANCELLED_PROMISE;
15 import static org.jetbrains.concurrency.InternalPromiseUtil.isHandlerObsolete;
16
17 class DonePromise<T> extends InternalPromiseUtil.BasePromise<T> {
18   private final PromiseValue<T> value;
19
20   DonePromise(@NotNull PromiseValue<T> value) {
21     this.value = value;
22   }
23
24   @NotNull
25   @Override
26   public Promise<T> onSuccess(@NotNull Consumer<? super T> handler) {
27     if (value.error != null) {
28       return this;
29     }
30
31     if (!isHandlerObsolete(handler)) {
32       handler.accept(value.result);
33     }
34     return this;
35   }
36
37   @NotNull
38   @Override
39   public Promise<T> processed(@NotNull Promise<? super T> child) {
40     if (child instanceof InternalPromiseUtil.PromiseImpl) {
41       //noinspection unchecked
42       ((InternalPromiseUtil.PromiseImpl<T>)child)._setValue(value);
43     }
44     else if (child instanceof InternalPromiseUtil.CompletablePromise) {
45       //noinspection unchecked
46       ((InternalPromiseUtil.CompletablePromise<T>)child).setResult(value.result);
47     }
48     return this;
49   }
50
51   @NotNull
52   @Override
53   public Promise<T> onProcessed(@NotNull Consumer<? super T> handler) {
54     if (value.error == null) {
55       onSuccess(handler);
56     }
57     else if (!isHandlerObsolete(handler)) {
58       handler.accept(null);
59     }
60     return this;
61   }
62
63   @NotNull
64   @Override
65   public Promise<T> onError(@NotNull Consumer<Throwable> handler) {
66     if (value.error != null && !isHandlerObsolete(handler)) {
67       handler.accept(value.error);
68     }
69     return this;
70   }
71
72   @NotNull
73   @Override
74   public <SUB_RESULT> Promise<SUB_RESULT> then(@NotNull Function<? super T, ? extends SUB_RESULT> done) {
75     if (value.error != null) {
76       //noinspection unchecked
77       return (Promise<SUB_RESULT>)this;
78     }
79     else if (isHandlerObsolete(done)) {
80       //noinspection unchecked
81       return (Promise<SUB_RESULT>)CANCELLED_PROMISE.getValue();
82     }
83     else {
84       return new DonePromise<>(PromiseValue.createFulfilled(done.fun(value.result)));
85     }
86   }
87
88   @NotNull
89   @Override
90   public <SUB_RESULT> Promise<SUB_RESULT> thenAsync(@NotNull Function<? super T, Promise<SUB_RESULT>> done) {
91     if (value.error == null) {
92       return done.fun(value.result);
93     }
94     else {
95       //noinspection unchecked
96       return (Promise<SUB_RESULT>)this;
97     }
98   }
99
100   @Nullable
101   @Override
102   public T blockingGet(int timeout, @NotNull TimeUnit timeUnit) throws ExecutionException, TimeoutException {
103     return value.getResultOrThrowError();
104   }
105
106   @Override
107   public void _setValue(@NotNull PromiseValue<T> value) {
108   }
109
110   @Nullable
111   @Override
112   protected PromiseValue<T> getValue() {
113     return value;
114   }
115
116   @Override
117   public void cancel() {
118   }
119 }