Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(193)

Side by Side Diff: components/scheduler/promises/rejectable.h

Issue 1401553002: NOT INTENDED FOR LANDING: A promises demo (Closed) Base URL: https://chromium.googlesource.com/chromium/src.git@master
Patch Set: Support for rejectatble promises! Created 4 years, 8 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch
OLDNEW
(Empty)
1 // Copyright 2016 The Chromium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4
5 #ifndef COMPONENTS_SCHEDULER_PROMISES_REJECTABLE_H_
6 #define COMPONENTS_SCHEDULER_PROMISES_REJECTABLE_H_
7
8 #include "components/scheduler/scheduler_export.h"
9 #include "components/scheduler/promises/template_helpers.h"
10
11 namespace promise {
12 namespace internal {
13 template <typename ResolveT>
14 class Resolve {
15 public:
16 explicit Resolve(const ResolveT& resolved) : resolved_(resolved) {}
17 explicit Resolve(ResolveT&& resolved) : resolved_(std::move(resolved)) {}
18
19 ResolveT resolved() const { return resolved_; }
20
21 private:
22 ResolveT resolved_;
23 };
24
25 template <>
26 class Resolve<void> {
27 public:
28 Resolve() {}
29 };
30
31 template <typename RejectT>
32 class Reject {
33 public:
34 explicit Reject(const RejectT& reject_reason)
35 : reject_reason_(reject_reason) {}
36
37 explicit Reject(RejectT&& reject_reason)
38 : reject_reason_(std::move(reject_reason)) {}
39
40 RejectT reject_reason() const { return reject_reason_; }
41
42 private:
43 RejectT reject_reason_;
44 };
45
46 template <>
47 class Reject<void> {
48 public:
49 Reject() {}
50 };
51
52 } // namespace internal
53
54 // Syntatic sugar for Reject() and Resolve()
55 template <typename ResolveT>
56 internal::Resolve<ResolveT> Resolve(ResolveT resolved) {
57 return internal::Resolve<ResolveT>(std::move(resolved));
58 }
59
60 inline internal::Resolve<void> Resolve() {
61 return internal::Resolve<void>();
62 }
63
64 template <typename RejectT>
65 internal::Reject<RejectT> Reject(RejectT reject_reason) {
66 return internal::Reject<RejectT>(std::move(reject_reason));
67 }
68
69 inline internal::Reject<void> Reject() {
70 return internal::Reject<void>();
71 }
72
73 class BaseRejectable {
74 public:
75 enum class State { UNRESOLVED, RESOLVED, REJECTED };
76
77 explicit BaseRejectable(State state) : state_(state) {}
78
79 bool is_rejected() const { return state_ == State::REJECTED; }
80 bool is_resolved() const { return state_ == State::RESOLVED; }
81 bool is_unresolved() const { return state_ == State::UNRESOLVED; }
82
83 protected:
84 State state_;
85 };
86
87 template <typename ResolveT, typename RejectT>
88 class Rejectable : public BaseRejectable {
89 public:
90 Rejectable() : BaseRejectable(State::UNRESOLVED) {}
91
92 Rejectable(const internal::Resolve<ResolveT>& resolved)
93 : BaseRejectable(State::RESOLVED),
94 resolved_(std::move(resolved.resolved())) {}
95
96 Rejectable(const internal::Reject<RejectT>& resolved)
97 : BaseRejectable(State::REJECTED),
98 reject_reason_(std::move(resolved.reject_reason())) {}
99
100 ResolveT& resolved() {
101 DCHECK(is_resolved());
102 return resolved_;
103 }
104
105 RejectT& reject_reason() {
106 DCHECK(is_rejected());
107 return reject_reason_;
108 }
109
110 void Resolve(const ResolveT& resolved) {
111 resolved_ = resolved;
112 BaseRejectable::state_ = BaseRejectable::State::RESOLVED;
113 }
114
115 void Resolve(ResolveT&& resolved) {
116 resolved_ = std::move(resolved);
117 BaseRejectable::state_ = BaseRejectable::State::RESOLVED;
118 }
119
120 void Reject(const RejectT& reject_reason) {
121 reject_reason_ = reject_reason;
122 BaseRejectable::state_ = BaseRejectable::State::REJECTED;
123 }
124
125 void Reject(RejectT&& reject_reason) {
126 reject_reason_ = std::move(reject_reason);
127 BaseRejectable::state_ = BaseRejectable::State::REJECTED;
128 }
129
130 private:
131 ResolveT resolved_;
132 RejectT reject_reason_;
133 };
134
135 template <typename ResolveT>
136 class Rejectable<ResolveT, void> : public BaseRejectable {
137 public:
138 Rejectable() : BaseRejectable(State::UNRESOLVED) {}
139
140 Rejectable(const internal::Resolve<ResolveT>& resolved)
141 : BaseRejectable(State::RESOLVED),
142 resolved_(std::move(resolved.resolved())) {}
143
144 Rejectable(const internal::Reject<void>& resolved)
145 : BaseRejectable(State::REJECTED) {}
146
147 ResolveT& resolved() {
148 DCHECK(is_resolved());
149 return resolved_;
150 }
151
152 void Resolve(const ResolveT& resolved) {
153 resolved_ = resolved;
154 BaseRejectable::state_ = BaseRejectable::State::RESOLVED;
155 }
156
157 void Resolve(ResolveT&& resolved) {
158 resolved_ = std::move(resolved);
159 BaseRejectable::state_ = BaseRejectable::State::RESOLVED;
160 }
161
162 void Reject() { BaseRejectable::state_ = BaseRejectable::State::REJECTED; }
163
164 private:
165 ResolveT resolved_;
166 bool is_rejected_;
167 };
168
169 template <typename RejectT>
170 class Rejectable<void, RejectT> : public BaseRejectable {
171 public:
172 Rejectable() : BaseRejectable(State::UNRESOLVED) {}
173
174 Rejectable(const internal::Resolve<void>& resolved)
175 : BaseRejectable(State::RESOLVED) {}
176
177 Rejectable(const internal::Reject<RejectT>& resolved)
178 : BaseRejectable(State::REJECTED),
179 reject_reason_(std::move(resolved.reject_reason())) {}
180
181 RejectT& reject_reason() {
182 DCHECK(is_rejected());
183 return reject_reason_;
184 }
185
186 void Resolve() { BaseRejectable::state_ = BaseRejectable::State::RESOLVED; }
187
188 void Reject(const RejectT& reject_reason) {
189 reject_reason_ = reject_reason;
190 BaseRejectable::state_ = BaseRejectable::State::REJECTED;
191 }
192
193 void Reject(RejectT&& reject_reason) {
194 reject_reason_ = std::move(reject_reason);
195 BaseRejectable::state_ = BaseRejectable::State::REJECTED;
196 }
197
198 private:
199 RejectT reject_reason_;
200 };
201
202 template <>
203 class Rejectable<void, void> : public BaseRejectable {
204 public:
205 Rejectable() : BaseRejectable(State::UNRESOLVED) {}
206
207 Rejectable(const internal::Resolve<void>& resolved)
208 : BaseRejectable(State::RESOLVED) {}
209
210 Rejectable(const internal::Reject<void>& resolved)
211 : BaseRejectable(State::REJECTED) {}
212
213 void Resolve() { BaseRejectable::state_ = BaseRejectable::State::RESOLVED; }
214
215 void Reject() { BaseRejectable::state_ = BaseRejectable::State::REJECTED; }
216 };
217
218 // Similar to std::enable_if but used to detect if a template parameter is a
219 // Rejectable<>.
220 template <typename R, class ResultT = void>
221 struct enable_if_rejectable {};
222
223 template <typename ResolveT, typename RejectT, class ResultT>
224 struct enable_if_rejectable<Rejectable<ResolveT, RejectT>, ResultT> {
225 typedef ResultT type;
226 };
227
228 } // namespace promise
229
230 #endif // COMPONENTS_SCHEDULER_PROMISES_REJECTABLE_H_
OLDNEW
« no previous file with comments | « components/scheduler/promises/promise_unittest.cc ('k') | components/scheduler/promises/single_thread_promise_executor.h » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698