1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
|
//
// Copyright Aliaksei Levin (levlam@telegram.org), Arseny Smirnov (arseny30@gmail.com) 2014-2025
//
// Distributed under the Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
//
#pragma once
#include "td/utils/common.h"
#include "td/utils/Status.h"
#include "td/utils/StringBuilder.h"
#include <type_traits>
#include <utility>
namespace td {
template <class T, bool = std::is_copy_constructible<T>::value>
class optional {
public:
optional() = default;
template <class T1,
std::enable_if_t<!std::is_same<std::decay_t<T1>, optional>::value && std::is_constructible<T, T1>::value,
int> = 0>
optional(T1 &&t) : impl_(std::forward<T1>(t)) {
}
optional(const optional &other) {
if (other) {
impl_ = Result<T>(other.value());
}
}
optional &operator=(const optional &other) {
if (this == &other) {
return *this;
}
if (other) {
impl_ = Result<T>(other.value());
} else {
impl_ = Result<T>();
}
return *this;
}
optional(optional &&) = default;
optional &operator=(optional &&) = default;
~optional() = default;
explicit operator bool() const noexcept {
return impl_.is_ok();
}
T &value() {
DCHECK(*this);
return impl_.ok_ref();
}
const T &value() const {
DCHECK(*this);
return impl_.ok_ref();
}
T &operator*() {
return value();
}
const T &operator*() const {
return value();
}
T unwrap() {
CHECK(*this);
auto res = std::move(value());
impl_ = {};
return res;
}
optional<T> copy() const {
if (*this) {
return value();
}
return {};
}
template <class... ArgsT>
void emplace(ArgsT &&...args) {
impl_.emplace(std::forward<ArgsT>(args)...);
}
private:
Result<T> impl_;
};
template <typename T>
struct optional<T, false> : optional<T, true> {
optional() = default;
using optional<T, true>::optional;
optional(const optional &) = delete;
optional &operator=(const optional &) = delete;
optional(optional &&) = default;
optional &operator=(optional &&) = default;
~optional() = default;
};
template <class T, class S>
bool operator==(const optional<T> &a, const optional<S> &b) {
if (a) {
return static_cast<bool>(b) && a.value() == b.value();
}
return !static_cast<bool>(b);
}
template <class T>
bool operator==(const T &a, const optional<T> &b) {
return static_cast<bool>(b) && a == b.value();
}
template <class T>
bool operator==(const optional<T> &a, const T &b) {
return static_cast<bool>(a) && a.value() == b;
}
template <class T>
StringBuilder &operator<<(StringBuilder &sb, const optional<T> &v) {
if (v) {
return sb << "Some{" << v.value() << "}";
}
return sb << "None";
}
} // namespace td
|
