|
318
|
1 // Copyright Toru Niina 2017.
|
|
|
2 // Distributed under the MIT License.
|
|
|
3 #ifndef TOML11_RESULT_HPP
|
|
|
4 #define TOML11_RESULT_HPP
|
|
|
5 #include "traits.hpp"
|
|
|
6 #include <type_traits>
|
|
|
7 #include <stdexcept>
|
|
|
8 #include <utility>
|
|
|
9 #include <new>
|
|
|
10 #include <string>
|
|
|
11 #include <sstream>
|
|
|
12 #include <cassert>
|
|
|
13
|
|
|
14 namespace toml
|
|
|
15 {
|
|
|
16
|
|
|
17 template<typename T>
|
|
|
18 struct success
|
|
|
19 {
|
|
|
20 using value_type = T;
|
|
|
21 value_type value;
|
|
|
22
|
|
|
23 explicit success(const value_type& v)
|
|
|
24 noexcept(std::is_nothrow_copy_constructible<value_type>::value)
|
|
|
25 : value(v)
|
|
|
26 {}
|
|
|
27 explicit success(value_type&& v)
|
|
|
28 noexcept(std::is_nothrow_move_constructible<value_type>::value)
|
|
|
29 : value(std::move(v))
|
|
|
30 {}
|
|
|
31
|
|
|
32 template<typename U>
|
|
|
33 explicit success(U&& v): value(std::forward<U>(v)) {}
|
|
|
34
|
|
|
35 template<typename U>
|
|
|
36 explicit success(const success<U>& v): value(v.value) {}
|
|
|
37 template<typename U>
|
|
|
38 explicit success(success<U>&& v): value(std::move(v.value)) {}
|
|
|
39
|
|
|
40 ~success() = default;
|
|
|
41 success(const success&) = default;
|
|
|
42 success(success&&) = default;
|
|
|
43 success& operator=(const success&) = default;
|
|
|
44 success& operator=(success&&) = default;
|
|
|
45 };
|
|
|
46
|
|
|
47 template<typename T>
|
|
|
48 struct failure
|
|
|
49 {
|
|
|
50 using value_type = T;
|
|
|
51 value_type value;
|
|
|
52
|
|
|
53 explicit failure(const value_type& v)
|
|
|
54 noexcept(std::is_nothrow_copy_constructible<value_type>::value)
|
|
|
55 : value(v)
|
|
|
56 {}
|
|
|
57 explicit failure(value_type&& v)
|
|
|
58 noexcept(std::is_nothrow_move_constructible<value_type>::value)
|
|
|
59 : value(std::move(v))
|
|
|
60 {}
|
|
|
61
|
|
|
62 template<typename U>
|
|
|
63 explicit failure(U&& v): value(std::forward<U>(v)) {}
|
|
|
64
|
|
|
65 template<typename U>
|
|
|
66 explicit failure(const failure<U>& v): value(v.value) {}
|
|
|
67 template<typename U>
|
|
|
68 explicit failure(failure<U>&& v): value(std::move(v.value)) {}
|
|
|
69
|
|
|
70 ~failure() = default;
|
|
|
71 failure(const failure&) = default;
|
|
|
72 failure(failure&&) = default;
|
|
|
73 failure& operator=(const failure&) = default;
|
|
|
74 failure& operator=(failure&&) = default;
|
|
|
75 };
|
|
|
76
|
|
|
77 template<typename T>
|
|
|
78 success<typename std::remove_cv<typename std::remove_reference<T>::type>::type>
|
|
|
79 ok(T&& v)
|
|
|
80 {
|
|
|
81 return success<
|
|
|
82 typename std::remove_cv<typename std::remove_reference<T>::type>::type
|
|
|
83 >(std::forward<T>(v));
|
|
|
84 }
|
|
|
85 template<typename T>
|
|
|
86 failure<typename std::remove_cv<typename std::remove_reference<T>::type>::type>
|
|
|
87 err(T&& v)
|
|
|
88 {
|
|
|
89 return failure<
|
|
|
90 typename std::remove_cv<typename std::remove_reference<T>::type>::type
|
|
|
91 >(std::forward<T>(v));
|
|
|
92 }
|
|
|
93
|
|
|
94 inline success<std::string> ok(const char* literal)
|
|
|
95 {
|
|
|
96 return success<std::string>(std::string(literal));
|
|
|
97 }
|
|
|
98 inline failure<std::string> err(const char* literal)
|
|
|
99 {
|
|
|
100 return failure<std::string>(std::string(literal));
|
|
|
101 }
|
|
|
102
|
|
|
103
|
|
|
104 template<typename T, typename E>
|
|
|
105 struct result
|
|
|
106 {
|
|
|
107 using value_type = T;
|
|
|
108 using error_type = E;
|
|
|
109 using success_type = success<value_type>;
|
|
|
110 using failure_type = failure<error_type>;
|
|
|
111
|
|
|
112 result(const success_type& s): is_ok_(true)
|
|
|
113 {
|
|
|
114 auto tmp = ::new(std::addressof(this->succ)) success_type(s);
|
|
|
115 assert(tmp == std::addressof(this->succ));
|
|
|
116 (void)tmp;
|
|
|
117 }
|
|
|
118 result(const failure_type& f): is_ok_(false)
|
|
|
119 {
|
|
|
120 auto tmp = ::new(std::addressof(this->fail)) failure_type(f);
|
|
|
121 assert(tmp == std::addressof(this->fail));
|
|
|
122 (void)tmp;
|
|
|
123 }
|
|
|
124 result(success_type&& s): is_ok_(true)
|
|
|
125 {
|
|
|
126 auto tmp = ::new(std::addressof(this->succ)) success_type(std::move(s));
|
|
|
127 assert(tmp == std::addressof(this->succ));
|
|
|
128 (void)tmp;
|
|
|
129 }
|
|
|
130 result(failure_type&& f): is_ok_(false)
|
|
|
131 {
|
|
|
132 auto tmp = ::new(std::addressof(this->fail)) failure_type(std::move(f));
|
|
|
133 assert(tmp == std::addressof(this->fail));
|
|
|
134 (void)tmp;
|
|
|
135 }
|
|
|
136
|
|
|
137 template<typename U>
|
|
|
138 result(const success<U>& s): is_ok_(true)
|
|
|
139 {
|
|
|
140 auto tmp = ::new(std::addressof(this->succ)) success_type(s.value);
|
|
|
141 assert(tmp == std::addressof(this->succ));
|
|
|
142 (void)tmp;
|
|
|
143 }
|
|
|
144 template<typename U>
|
|
|
145 result(const failure<U>& f): is_ok_(false)
|
|
|
146 {
|
|
|
147 auto tmp = ::new(std::addressof(this->fail)) failure_type(f.value);
|
|
|
148 assert(tmp == std::addressof(this->fail));
|
|
|
149 (void)tmp;
|
|
|
150 }
|
|
|
151 template<typename U>
|
|
|
152 result(success<U>&& s): is_ok_(true)
|
|
|
153 {
|
|
|
154 auto tmp = ::new(std::addressof(this->succ)) success_type(std::move(s.value));
|
|
|
155 assert(tmp == std::addressof(this->succ));
|
|
|
156 (void)tmp;
|
|
|
157 }
|
|
|
158 template<typename U>
|
|
|
159 result(failure<U>&& f): is_ok_(false)
|
|
|
160 {
|
|
|
161 auto tmp = ::new(std::addressof(this->fail)) failure_type(std::move(f.value));
|
|
|
162 assert(tmp == std::addressof(this->fail));
|
|
|
163 (void)tmp;
|
|
|
164 }
|
|
|
165
|
|
|
166 result& operator=(const success_type& s)
|
|
|
167 {
|
|
|
168 this->cleanup();
|
|
|
169 this->is_ok_ = true;
|
|
|
170 auto tmp = ::new(std::addressof(this->succ)) success_type(s);
|
|
|
171 assert(tmp == std::addressof(this->succ));
|
|
|
172 (void)tmp;
|
|
|
173 return *this;
|
|
|
174 }
|
|
|
175 result& operator=(const failure_type& f)
|
|
|
176 {
|
|
|
177 this->cleanup();
|
|
|
178 this->is_ok_ = false;
|
|
|
179 auto tmp = ::new(std::addressof(this->fail)) failure_type(f);
|
|
|
180 assert(tmp == std::addressof(this->fail));
|
|
|
181 (void)tmp;
|
|
|
182 return *this;
|
|
|
183 }
|
|
|
184 result& operator=(success_type&& s)
|
|
|
185 {
|
|
|
186 this->cleanup();
|
|
|
187 this->is_ok_ = true;
|
|
|
188 auto tmp = ::new(std::addressof(this->succ)) success_type(std::move(s));
|
|
|
189 assert(tmp == std::addressof(this->succ));
|
|
|
190 (void)tmp;
|
|
|
191 return *this;
|
|
|
192 }
|
|
|
193 result& operator=(failure_type&& f)
|
|
|
194 {
|
|
|
195 this->cleanup();
|
|
|
196 this->is_ok_ = false;
|
|
|
197 auto tmp = ::new(std::addressof(this->fail)) failure_type(std::move(f));
|
|
|
198 assert(tmp == std::addressof(this->fail));
|
|
|
199 (void)tmp;
|
|
|
200 return *this;
|
|
|
201 }
|
|
|
202
|
|
|
203 template<typename U>
|
|
|
204 result& operator=(const success<U>& s)
|
|
|
205 {
|
|
|
206 this->cleanup();
|
|
|
207 this->is_ok_ = true;
|
|
|
208 auto tmp = ::new(std::addressof(this->succ)) success_type(s.value);
|
|
|
209 assert(tmp == std::addressof(this->succ));
|
|
|
210 (void)tmp;
|
|
|
211 return *this;
|
|
|
212 }
|
|
|
213 template<typename U>
|
|
|
214 result& operator=(const failure<U>& f)
|
|
|
215 {
|
|
|
216 this->cleanup();
|
|
|
217 this->is_ok_ = false;
|
|
|
218 auto tmp = ::new(std::addressof(this->fail)) failure_type(f.value);
|
|
|
219 assert(tmp == std::addressof(this->fail));
|
|
|
220 (void)tmp;
|
|
|
221 return *this;
|
|
|
222 }
|
|
|
223 template<typename U>
|
|
|
224 result& operator=(success<U>&& s)
|
|
|
225 {
|
|
|
226 this->cleanup();
|
|
|
227 this->is_ok_ = true;
|
|
|
228 auto tmp = ::new(std::addressof(this->succ)) success_type(std::move(s.value));
|
|
|
229 assert(tmp == std::addressof(this->succ));
|
|
|
230 (void)tmp;
|
|
|
231 return *this;
|
|
|
232 }
|
|
|
233 template<typename U>
|
|
|
234 result& operator=(failure<U>&& f)
|
|
|
235 {
|
|
|
236 this->cleanup();
|
|
|
237 this->is_ok_ = false;
|
|
|
238 auto tmp = ::new(std::addressof(this->fail)) failure_type(std::move(f.value));
|
|
|
239 assert(tmp == std::addressof(this->fail));
|
|
|
240 (void)tmp;
|
|
|
241 return *this;
|
|
|
242 }
|
|
|
243
|
|
|
244 ~result() noexcept {this->cleanup();}
|
|
|
245
|
|
|
246 result(const result& other): is_ok_(other.is_ok())
|
|
|
247 {
|
|
|
248 if(other.is_ok())
|
|
|
249 {
|
|
|
250 auto tmp = ::new(std::addressof(this->succ)) success_type(other.as_ok());
|
|
|
251 assert(tmp == std::addressof(this->succ));
|
|
|
252 (void)tmp;
|
|
|
253 }
|
|
|
254 else
|
|
|
255 {
|
|
|
256 auto tmp = ::new(std::addressof(this->fail)) failure_type(other.as_err());
|
|
|
257 assert(tmp == std::addressof(this->fail));
|
|
|
258 (void)tmp;
|
|
|
259 }
|
|
|
260 }
|
|
|
261 result(result&& other): is_ok_(other.is_ok())
|
|
|
262 {
|
|
|
263 if(other.is_ok())
|
|
|
264 {
|
|
|
265 auto tmp = ::new(std::addressof(this->succ)) success_type(std::move(other.as_ok()));
|
|
|
266 assert(tmp == std::addressof(this->succ));
|
|
|
267 (void)tmp;
|
|
|
268 }
|
|
|
269 else
|
|
|
270 {
|
|
|
271 auto tmp = ::new(std::addressof(this->fail)) failure_type(std::move(other.as_err()));
|
|
|
272 assert(tmp == std::addressof(this->fail));
|
|
|
273 (void)tmp;
|
|
|
274 }
|
|
|
275 }
|
|
|
276
|
|
|
277 template<typename U, typename F>
|
|
|
278 result(const result<U, F>& other): is_ok_(other.is_ok())
|
|
|
279 {
|
|
|
280 if(other.is_ok())
|
|
|
281 {
|
|
|
282 auto tmp = ::new(std::addressof(this->succ)) success_type(other.as_ok());
|
|
|
283 assert(tmp == std::addressof(this->succ));
|
|
|
284 (void)tmp;
|
|
|
285 }
|
|
|
286 else
|
|
|
287 {
|
|
|
288 auto tmp = ::new(std::addressof(this->fail)) failure_type(other.as_err());
|
|
|
289 assert(tmp == std::addressof(this->fail));
|
|
|
290 (void)tmp;
|
|
|
291 }
|
|
|
292 }
|
|
|
293 template<typename U, typename F>
|
|
|
294 result(result<U, F>&& other): is_ok_(other.is_ok())
|
|
|
295 {
|
|
|
296 if(other.is_ok())
|
|
|
297 {
|
|
|
298 auto tmp = ::new(std::addressof(this->succ)) success_type(std::move(other.as_ok()));
|
|
|
299 assert(tmp == std::addressof(this->succ));
|
|
|
300 (void)tmp;
|
|
|
301 }
|
|
|
302 else
|
|
|
303 {
|
|
|
304 auto tmp = ::new(std::addressof(this->fail)) failure_type(std::move(other.as_err()));
|
|
|
305 assert(tmp == std::addressof(this->fail));
|
|
|
306 (void)tmp;
|
|
|
307 }
|
|
|
308 }
|
|
|
309
|
|
|
310 result& operator=(const result& other)
|
|
|
311 {
|
|
|
312 this->cleanup();
|
|
|
313 if(other.is_ok())
|
|
|
314 {
|
|
|
315 auto tmp = ::new(std::addressof(this->succ)) success_type(other.as_ok());
|
|
|
316 assert(tmp == std::addressof(this->succ));
|
|
|
317 (void)tmp;
|
|
|
318 }
|
|
|
319 else
|
|
|
320 {
|
|
|
321 auto tmp = ::new(std::addressof(this->fail)) failure_type(other.as_err());
|
|
|
322 assert(tmp == std::addressof(this->fail));
|
|
|
323 (void)tmp;
|
|
|
324 }
|
|
|
325 is_ok_ = other.is_ok();
|
|
|
326 return *this;
|
|
|
327 }
|
|
|
328 result& operator=(result&& other)
|
|
|
329 {
|
|
|
330 this->cleanup();
|
|
|
331 if(other.is_ok())
|
|
|
332 {
|
|
|
333 auto tmp = ::new(std::addressof(this->succ)) success_type(std::move(other.as_ok()));
|
|
|
334 assert(tmp == std::addressof(this->succ));
|
|
|
335 (void)tmp;
|
|
|
336 }
|
|
|
337 else
|
|
|
338 {
|
|
|
339 auto tmp = ::new(std::addressof(this->fail)) failure_type(std::move(other.as_err()));
|
|
|
340 assert(tmp == std::addressof(this->fail));
|
|
|
341 (void)tmp;
|
|
|
342 }
|
|
|
343 is_ok_ = other.is_ok();
|
|
|
344 return *this;
|
|
|
345 }
|
|
|
346
|
|
|
347 template<typename U, typename F>
|
|
|
348 result& operator=(const result<U, F>& other)
|
|
|
349 {
|
|
|
350 this->cleanup();
|
|
|
351 if(other.is_ok())
|
|
|
352 {
|
|
|
353 auto tmp = ::new(std::addressof(this->succ)) success_type(other.as_ok());
|
|
|
354 assert(tmp == std::addressof(this->succ));
|
|
|
355 (void)tmp;
|
|
|
356 }
|
|
|
357 else
|
|
|
358 {
|
|
|
359 auto tmp = ::new(std::addressof(this->fail)) failure_type(other.as_err());
|
|
|
360 assert(tmp == std::addressof(this->fail));
|
|
|
361 (void)tmp;
|
|
|
362 }
|
|
|
363 is_ok_ = other.is_ok();
|
|
|
364 return *this;
|
|
|
365 }
|
|
|
366 template<typename U, typename F>
|
|
|
367 result& operator=(result<U, F>&& other)
|
|
|
368 {
|
|
|
369 this->cleanup();
|
|
|
370 if(other.is_ok())
|
|
|
371 {
|
|
|
372 auto tmp = ::new(std::addressof(this->succ)) success_type(std::move(other.as_ok()));
|
|
|
373 assert(tmp == std::addressof(this->succ));
|
|
|
374 (void)tmp;
|
|
|
375 }
|
|
|
376 else
|
|
|
377 {
|
|
|
378 auto tmp = ::new(std::addressof(this->fail)) failure_type(std::move(other.as_err()));
|
|
|
379 assert(tmp == std::addressof(this->fail));
|
|
|
380 (void)tmp;
|
|
|
381 }
|
|
|
382 is_ok_ = other.is_ok();
|
|
|
383 return *this;
|
|
|
384 }
|
|
|
385
|
|
|
386 bool is_ok() const noexcept {return is_ok_;}
|
|
|
387 bool is_err() const noexcept {return !is_ok_;}
|
|
|
388
|
|
|
389 operator bool() const noexcept {return is_ok_;}
|
|
|
390
|
|
|
391 value_type& unwrap() &
|
|
|
392 {
|
|
|
393 if(is_err())
|
|
|
394 {
|
|
|
395 throw std::runtime_error("toml::result: bad unwrap: " +
|
|
|
396 format_error(this->as_err()));
|
|
|
397 }
|
|
|
398 return this->succ.value;
|
|
|
399 }
|
|
|
400 value_type const& unwrap() const&
|
|
|
401 {
|
|
|
402 if(is_err())
|
|
|
403 {
|
|
|
404 throw std::runtime_error("toml::result: bad unwrap: " +
|
|
|
405 format_error(this->as_err()));
|
|
|
406 }
|
|
|
407 return this->succ.value;
|
|
|
408 }
|
|
|
409 value_type&& unwrap() &&
|
|
|
410 {
|
|
|
411 if(is_err())
|
|
|
412 {
|
|
|
413 throw std::runtime_error("toml::result: bad unwrap: " +
|
|
|
414 format_error(this->as_err()));
|
|
|
415 }
|
|
|
416 return std::move(this->succ.value);
|
|
|
417 }
|
|
|
418
|
|
|
419 value_type& unwrap_or(value_type& opt) &
|
|
|
420 {
|
|
|
421 if(is_err()) {return opt;}
|
|
|
422 return this->succ.value;
|
|
|
423 }
|
|
|
424 value_type const& unwrap_or(value_type const& opt) const&
|
|
|
425 {
|
|
|
426 if(is_err()) {return opt;}
|
|
|
427 return this->succ.value;
|
|
|
428 }
|
|
|
429 value_type unwrap_or(value_type opt) &&
|
|
|
430 {
|
|
|
431 if(is_err()) {return opt;}
|
|
|
432 return this->succ.value;
|
|
|
433 }
|
|
|
434
|
|
|
435 error_type& unwrap_err() &
|
|
|
436 {
|
|
|
437 if(is_ok()) {throw std::runtime_error("toml::result: bad unwrap_err");}
|
|
|
438 return this->fail.value;
|
|
|
439 }
|
|
|
440 error_type const& unwrap_err() const&
|
|
|
441 {
|
|
|
442 if(is_ok()) {throw std::runtime_error("toml::result: bad unwrap_err");}
|
|
|
443 return this->fail.value;
|
|
|
444 }
|
|
|
445 error_type&& unwrap_err() &&
|
|
|
446 {
|
|
|
447 if(is_ok()) {throw std::runtime_error("toml::result: bad unwrap_err");}
|
|
|
448 return std::move(this->fail.value);
|
|
|
449 }
|
|
|
450
|
|
|
451 value_type& as_ok() & noexcept {return this->succ.value;}
|
|
|
452 value_type const& as_ok() const& noexcept {return this->succ.value;}
|
|
|
453 value_type&& as_ok() && noexcept {return std::move(this->succ.value);}
|
|
|
454
|
|
|
455 error_type& as_err() & noexcept {return this->fail.value;}
|
|
|
456 error_type const& as_err() const& noexcept {return this->fail.value;}
|
|
|
457 error_type&& as_err() && noexcept {return std::move(this->fail.value);}
|
|
|
458
|
|
|
459
|
|
|
460 // prerequisities
|
|
|
461 // F: T -> U
|
|
|
462 // retval: result<U, E>
|
|
|
463 template<typename F>
|
|
|
464 result<detail::return_type_of_t<F, value_type&>, error_type>
|
|
|
465 map(F&& f) &
|
|
|
466 {
|
|
|
467 if(this->is_ok()){return ok(f(this->as_ok()));}
|
|
|
468 return err(this->as_err());
|
|
|
469 }
|
|
|
470 template<typename F>
|
|
|
471 result<detail::return_type_of_t<F, value_type const&>, error_type>
|
|
|
472 map(F&& f) const&
|
|
|
473 {
|
|
|
474 if(this->is_ok()){return ok(f(this->as_ok()));}
|
|
|
475 return err(this->as_err());
|
|
|
476 }
|
|
|
477 template<typename F>
|
|
|
478 result<detail::return_type_of_t<F, value_type &&>, error_type>
|
|
|
479 map(F&& f) &&
|
|
|
480 {
|
|
|
481 if(this->is_ok()){return ok(f(std::move(this->as_ok())));}
|
|
|
482 return err(std::move(this->as_err()));
|
|
|
483 }
|
|
|
484
|
|
|
485 // prerequisities
|
|
|
486 // F: E -> F
|
|
|
487 // retval: result<T, F>
|
|
|
488 template<typename F>
|
|
|
489 result<value_type, detail::return_type_of_t<F, error_type&>>
|
|
|
490 map_err(F&& f) &
|
|
|
491 {
|
|
|
492 if(this->is_err()){return err(f(this->as_err()));}
|
|
|
493 return ok(this->as_ok());
|
|
|
494 }
|
|
|
495 template<typename F>
|
|
|
496 result<value_type, detail::return_type_of_t<F, error_type const&>>
|
|
|
497 map_err(F&& f) const&
|
|
|
498 {
|
|
|
499 if(this->is_err()){return err(f(this->as_err()));}
|
|
|
500 return ok(this->as_ok());
|
|
|
501 }
|
|
|
502 template<typename F>
|
|
|
503 result<value_type, detail::return_type_of_t<F, error_type&&>>
|
|
|
504 map_err(F&& f) &&
|
|
|
505 {
|
|
|
506 if(this->is_err()){return err(f(std::move(this->as_err())));}
|
|
|
507 return ok(std::move(this->as_ok()));
|
|
|
508 }
|
|
|
509
|
|
|
510 // prerequisities
|
|
|
511 // F: T -> U
|
|
|
512 // retval: U
|
|
|
513 template<typename F, typename U>
|
|
|
514 detail::return_type_of_t<F, value_type&>
|
|
|
515 map_or_else(F&& f, U&& opt) &
|
|
|
516 {
|
|
|
517 if(this->is_err()){return std::forward<U>(opt);}
|
|
|
518 return f(this->as_ok());
|
|
|
519 }
|
|
|
520 template<typename F, typename U>
|
|
|
521 detail::return_type_of_t<F, value_type const&>
|
|
|
522 map_or_else(F&& f, U&& opt) const&
|
|
|
523 {
|
|
|
524 if(this->is_err()){return std::forward<U>(opt);}
|
|
|
525 return f(this->as_ok());
|
|
|
526 }
|
|
|
527 template<typename F, typename U>
|
|
|
528 detail::return_type_of_t<F, value_type&&>
|
|
|
529 map_or_else(F&& f, U&& opt) &&
|
|
|
530 {
|
|
|
531 if(this->is_err()){return std::forward<U>(opt);}
|
|
|
532 return f(std::move(this->as_ok()));
|
|
|
533 }
|
|
|
534
|
|
|
535 // prerequisities
|
|
|
536 // F: E -> U
|
|
|
537 // retval: U
|
|
|
538 template<typename F, typename U>
|
|
|
539 detail::return_type_of_t<F, error_type&>
|
|
|
540 map_err_or_else(F&& f, U&& opt) &
|
|
|
541 {
|
|
|
542 if(this->is_ok()){return std::forward<U>(opt);}
|
|
|
543 return f(this->as_err());
|
|
|
544 }
|
|
|
545 template<typename F, typename U>
|
|
|
546 detail::return_type_of_t<F, error_type const&>
|
|
|
547 map_err_or_else(F&& f, U&& opt) const&
|
|
|
548 {
|
|
|
549 if(this->is_ok()){return std::forward<U>(opt);}
|
|
|
550 return f(this->as_err());
|
|
|
551 }
|
|
|
552 template<typename F, typename U>
|
|
|
553 detail::return_type_of_t<F, error_type&&>
|
|
|
554 map_err_or_else(F&& f, U&& opt) &&
|
|
|
555 {
|
|
|
556 if(this->is_ok()){return std::forward<U>(opt);}
|
|
|
557 return f(std::move(this->as_err()));
|
|
|
558 }
|
|
|
559
|
|
|
560 // prerequisities:
|
|
|
561 // F: func T -> U
|
|
|
562 // toml::err(error_type) should be convertible to U.
|
|
|
563 // normally, type U is another result<S, F> and E is convertible to F
|
|
|
564 template<typename F>
|
|
|
565 detail::return_type_of_t<F, value_type&>
|
|
|
566 and_then(F&& f) &
|
|
|
567 {
|
|
|
568 if(this->is_ok()){return f(this->as_ok());}
|
|
|
569 return err(this->as_err());
|
|
|
570 }
|
|
|
571 template<typename F>
|
|
|
572 detail::return_type_of_t<F, value_type const&>
|
|
|
573 and_then(F&& f) const&
|
|
|
574 {
|
|
|
575 if(this->is_ok()){return f(this->as_ok());}
|
|
|
576 return err(this->as_err());
|
|
|
577 }
|
|
|
578 template<typename F>
|
|
|
579 detail::return_type_of_t<F, value_type&&>
|
|
|
580 and_then(F&& f) &&
|
|
|
581 {
|
|
|
582 if(this->is_ok()){return f(std::move(this->as_ok()));}
|
|
|
583 return err(std::move(this->as_err()));
|
|
|
584 }
|
|
|
585
|
|
|
586 // prerequisities:
|
|
|
587 // F: func E -> U
|
|
|
588 // toml::ok(value_type) should be convertible to U.
|
|
|
589 // normally, type U is another result<S, F> and T is convertible to S
|
|
|
590 template<typename F>
|
|
|
591 detail::return_type_of_t<F, error_type&>
|
|
|
592 or_else(F&& f) &
|
|
|
593 {
|
|
|
594 if(this->is_err()){return f(this->as_err());}
|
|
|
595 return ok(this->as_ok());
|
|
|
596 }
|
|
|
597 template<typename F>
|
|
|
598 detail::return_type_of_t<F, error_type const&>
|
|
|
599 or_else(F&& f) const&
|
|
|
600 {
|
|
|
601 if(this->is_err()){return f(this->as_err());}
|
|
|
602 return ok(this->as_ok());
|
|
|
603 }
|
|
|
604 template<typename F>
|
|
|
605 detail::return_type_of_t<F, error_type&&>
|
|
|
606 or_else(F&& f) &&
|
|
|
607 {
|
|
|
608 if(this->is_err()){return f(std::move(this->as_err()));}
|
|
|
609 return ok(std::move(this->as_ok()));
|
|
|
610 }
|
|
|
611
|
|
|
612 // if *this is error, returns *this. otherwise, returns other.
|
|
|
613 result and_other(const result& other) const&
|
|
|
614 {
|
|
|
615 return this->is_err() ? *this : other;
|
|
|
616 }
|
|
|
617 result and_other(result&& other) &&
|
|
|
618 {
|
|
|
619 return this->is_err() ? std::move(*this) : std::move(other);
|
|
|
620 }
|
|
|
621
|
|
|
622 // if *this is okay, returns *this. otherwise, returns other.
|
|
|
623 result or_other(const result& other) const&
|
|
|
624 {
|
|
|
625 return this->is_ok() ? *this : other;
|
|
|
626 }
|
|
|
627 result or_other(result&& other) &&
|
|
|
628 {
|
|
|
629 return this->is_ok() ? std::move(*this) : std::move(other);
|
|
|
630 }
|
|
|
631
|
|
|
632 void swap(result<T, E>& other)
|
|
|
633 {
|
|
|
634 result<T, E> tmp(std::move(*this));
|
|
|
635 *this = std::move(other);
|
|
|
636 other = std::move(tmp);
|
|
|
637 return ;
|
|
|
638 }
|
|
|
639
|
|
|
640 private:
|
|
|
641
|
|
|
642 static std::string format_error(std::exception const& excpt)
|
|
|
643 {
|
|
|
644 return std::string(excpt.what());
|
|
|
645 }
|
|
|
646 template<typename U, typename std::enable_if<!std::is_base_of<
|
|
|
647 std::exception, U>::value, std::nullptr_t>::type = nullptr>
|
|
|
648 static std::string format_error(U const& others)
|
|
|
649 {
|
|
|
650 std::ostringstream oss; oss << others;
|
|
|
651 return oss.str();
|
|
|
652 }
|
|
|
653
|
|
|
654 void cleanup() noexcept
|
|
|
655 {
|
|
|
656 if(this->is_ok_) {this->succ.~success_type();}
|
|
|
657 else {this->fail.~failure_type();}
|
|
|
658 return;
|
|
|
659 }
|
|
|
660
|
|
|
661 private:
|
|
|
662
|
|
|
663 bool is_ok_;
|
|
|
664 union
|
|
|
665 {
|
|
|
666 success_type succ;
|
|
|
667 failure_type fail;
|
|
|
668 };
|
|
|
669 };
|
|
|
670
|
|
|
671 template<typename T, typename E>
|
|
|
672 void swap(result<T, E>& lhs, result<T, E>& rhs)
|
|
|
673 {
|
|
|
674 lhs.swap(rhs);
|
|
|
675 return;
|
|
|
676 }
|
|
|
677
|
|
|
678 // this might be confusing because it eagerly evaluated, while in the other
|
|
|
679 // cases operator && and || are short-circuited.
|
|
|
680 //
|
|
|
681 // template<typename T, typename E>
|
|
|
682 // inline result<T, E>
|
|
|
683 // operator&&(const result<T, E>& lhs, const result<T, E>& rhs) noexcept
|
|
|
684 // {
|
|
|
685 // return lhs.is_ok() ? rhs : lhs;
|
|
|
686 // }
|
|
|
687 //
|
|
|
688 // template<typename T, typename E>
|
|
|
689 // inline result<T, E>
|
|
|
690 // operator||(const result<T, E>& lhs, const result<T, E>& rhs) noexcept
|
|
|
691 // {
|
|
|
692 // return lhs.is_ok() ? lhs : rhs;
|
|
|
693 // }
|
|
|
694
|
|
|
695 // ----------------------------------------------------------------------------
|
|
|
696 // re-use result<T, E> as a optional<T> with none_t
|
|
|
697
|
|
|
698 namespace detail
|
|
|
699 {
|
|
|
700 struct none_t {};
|
|
|
701 inline bool operator==(const none_t&, const none_t&) noexcept {return true;}
|
|
|
702 inline bool operator!=(const none_t&, const none_t&) noexcept {return false;}
|
|
|
703 inline bool operator< (const none_t&, const none_t&) noexcept {return false;}
|
|
|
704 inline bool operator<=(const none_t&, const none_t&) noexcept {return true;}
|
|
|
705 inline bool operator> (const none_t&, const none_t&) noexcept {return false;}
|
|
|
706 inline bool operator>=(const none_t&, const none_t&) noexcept {return true;}
|
|
|
707 template<typename charT, typename traitsT>
|
|
|
708 std::basic_ostream<charT, traitsT>&
|
|
|
709 operator<<(std::basic_ostream<charT, traitsT>& os, const none_t&)
|
|
|
710 {
|
|
|
711 os << "none";
|
|
|
712 return os;
|
|
|
713 }
|
|
|
714 inline failure<none_t> none() noexcept {return failure<none_t>{none_t{}};}
|
|
|
715 } // detail
|
|
|
716 } // toml11
|
|
|
717 #endif// TOML11_RESULT_H
|
