1 //===-- Optional.h - Simple variant for passing optional values ---*- C++ -*-=//
2 //
3 //                     The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 //  This file provides Optional, a template class modeled in the spirit of
11 //  OCaml's 'opt' variant.  The idea is to strongly type whether or not
12 //  a value can be optional.
13 //
14 //===----------------------------------------------------------------------===//
15 
16 #ifndef LLVM_ADT_OPTIONAL_H
17 #define LLVM_ADT_OPTIONAL_H
18 
19 #include "llvm/ADT/None.h"
20 #include "llvm/Support/AlignOf.h"
21 #include "llvm/Support/Compiler.h"
22 #include <cassert>
23 #include <new>
24 #include <utility>
25 
26 namespace llvm {
27 
28 template<typename T>
29 class Optional {
30   AlignedCharArrayUnion<T> storage;
31   bool hasVal;
32 public:
33   typedef T value_type;
34 
Optional(NoneType)35   Optional(NoneType) : hasVal(false) {}
Optional()36   explicit Optional() : hasVal(false) {}
Optional(const T & y)37   Optional(const T &y) : hasVal(true) {
38     new (storage.buffer) T(y);
39   }
Optional(const Optional & O)40   Optional(const Optional &O) : hasVal(O.hasVal) {
41     if (hasVal)
42       new (storage.buffer) T(*O);
43   }
44 
Optional(T && y)45   Optional(T &&y) : hasVal(true) {
46     new (storage.buffer) T(std::forward<T>(y));
47   }
Optional(Optional<T> && O)48   Optional(Optional<T> &&O) : hasVal(O) {
49     if (O) {
50       new (storage.buffer) T(std::move(*O));
51       O.reset();
52     }
53   }
54   Optional &operator=(T &&y) {
55     if (hasVal)
56       **this = std::move(y);
57     else {
58       new (storage.buffer) T(std::move(y));
59       hasVal = true;
60     }
61     return *this;
62   }
63   Optional &operator=(Optional &&O) {
64     if (!O)
65       reset();
66     else {
67       *this = std::move(*O);
68       O.reset();
69     }
70     return *this;
71   }
72 
73   /// Create a new object by constructing it in place with the given arguments.
74   template<typename ...ArgTypes>
emplace(ArgTypes &&...Args)75   void emplace(ArgTypes &&...Args) {
76     reset();
77     hasVal = true;
78     new (storage.buffer) T(std::forward<ArgTypes>(Args)...);
79   }
80 
create(const T * y)81   static inline Optional create(const T* y) {
82     return y ? Optional(*y) : Optional();
83   }
84 
85   // FIXME: these assignments (& the equivalent const T&/const Optional& ctors)
86   // could be made more efficient by passing by value, possibly unifying them
87   // with the rvalue versions above - but this could place a different set of
88   // requirements (notably: the existence of a default ctor) when implemented
89   // in that way. Careful SFINAE to avoid such pitfalls would be required.
90   Optional &operator=(const T &y) {
91     if (hasVal)
92       **this = y;
93     else {
94       new (storage.buffer) T(y);
95       hasVal = true;
96     }
97     return *this;
98   }
99 
100   Optional &operator=(const Optional &O) {
101     if (!O)
102       reset();
103     else
104       *this = *O;
105     return *this;
106   }
107 
reset()108   void reset() {
109     if (hasVal) {
110       (**this).~T();
111       hasVal = false;
112     }
113   }
114 
~Optional()115   ~Optional() {
116     reset();
117   }
118 
getPointer()119   const T* getPointer() const { assert(hasVal); return reinterpret_cast<const T*>(storage.buffer); }
getPointer()120   T* getPointer() { assert(hasVal); return reinterpret_cast<T*>(storage.buffer); }
getValue()121   const T& getValue() const LLVM_LVALUE_FUNCTION { assert(hasVal); return *getPointer(); }
getValue()122   T& getValue() LLVM_LVALUE_FUNCTION { assert(hasVal); return *getPointer(); }
123 
124   explicit operator bool() const { return hasVal; }
hasValue()125   bool hasValue() const { return hasVal; }
126   const T* operator->() const { return getPointer(); }
127   T* operator->() { return getPointer(); }
128   const T& operator*() const LLVM_LVALUE_FUNCTION { assert(hasVal); return *getPointer(); }
129   T& operator*() LLVM_LVALUE_FUNCTION { assert(hasVal); return *getPointer(); }
130 
131   template <typename U>
getValueOr(U && value)132   constexpr T getValueOr(U &&value) const LLVM_LVALUE_FUNCTION {
133     return hasValue() ? getValue() : std::forward<U>(value);
134   }
135 
136 #if LLVM_HAS_RVALUE_REFERENCE_THIS
getValue()137   T&& getValue() && { assert(hasVal); return std::move(*getPointer()); }
138   T&& operator*() && { assert(hasVal); return std::move(*getPointer()); }
139 
140   template <typename U>
getValueOr(U && value)141   T getValueOr(U &&value) && {
142     return hasValue() ? std::move(getValue()) : std::forward<U>(value);
143   }
144 #endif
145 };
146 
147 template <typename T> struct isPodLike;
148 template <typename T> struct isPodLike<Optional<T> > {
149   // An Optional<T> is pod-like if T is.
150   static const bool value = isPodLike<T>::value;
151 };
152 
153 template <typename T, typename U>
154 bool operator==(const Optional<T> &X, const Optional<U> &Y) {
155   if (X && Y)
156     return *X == *Y;
157   return X.hasValue() == Y.hasValue();
158 }
159 
160 template <typename T, typename U>
161 bool operator!=(const Optional<T> &X, const Optional<U> &Y) {
162   return !(X == Y);
163 }
164 
165 template <typename T, typename U>
166 bool operator<(const Optional<T> &X, const Optional<U> &Y) {
167   if (X && Y)
168     return *X < *Y;
169   return X.hasValue() < Y.hasValue();
170 }
171 
172 template <typename T, typename U>
173 bool operator<=(const Optional<T> &X, const Optional<U> &Y) {
174   return !(Y < X);
175 }
176 
177 template <typename T, typename U>
178 bool operator>(const Optional<T> &X, const Optional<U> &Y) {
179   return Y < X;
180 }
181 
182 template <typename T, typename U>
183 bool operator>=(const Optional<T> &X, const Optional<U> &Y) {
184   return !(X < Y);
185 }
186 
187 template<typename T>
188 bool operator==(const Optional<T> &X, NoneType) {
189   return !X;
190 }
191 
192 template<typename T>
193 bool operator==(NoneType, const Optional<T> &X) {
194   return X == None;
195 }
196 
197 template<typename T>
198 bool operator!=(const Optional<T> &X, NoneType) {
199   return !(X == None);
200 }
201 
202 template<typename T>
203 bool operator!=(NoneType, const Optional<T> &X) {
204   return X != None;
205 }
206 
207 template <typename T> bool operator<(const Optional<T> &X, NoneType) {
208   return false;
209 }
210 
211 template <typename T> bool operator<(NoneType, const Optional<T> &X) {
212   return X.hasValue();
213 }
214 
215 template <typename T> bool operator<=(const Optional<T> &X, NoneType) {
216   return !(None < X);
217 }
218 
219 template <typename T> bool operator<=(NoneType, const Optional<T> &X) {
220   return !(X < None);
221 }
222 
223 template <typename T> bool operator>(const Optional<T> &X, NoneType) {
224   return None < X;
225 }
226 
227 template <typename T> bool operator>(NoneType, const Optional<T> &X) {
228   return X < None;
229 }
230 
231 template <typename T> bool operator>=(const Optional<T> &X, NoneType) {
232   return None <= X;
233 }
234 
235 template <typename T> bool operator>=(NoneType, const Optional<T> &X) {
236   return X <= None;
237 }
238 
239 template <typename T> bool operator==(const Optional<T> &X, const T &Y) {
240   return X && *X == Y;
241 }
242 
243 template <typename T> bool operator==(const T &X, const Optional<T> &Y) {
244   return Y && X == *Y;
245 }
246 
247 template <typename T> bool operator!=(const Optional<T> &X, const T &Y) {
248   return !(X == Y);
249 }
250 
251 template <typename T> bool operator!=(const T &X, const Optional<T> &Y) {
252   return !(X == Y);
253 }
254 
255 template <typename T> bool operator<(const Optional<T> &X, const T &Y) {
256   return !X || *X < Y;
257 }
258 
259 template <typename T> bool operator<(const T &X, const Optional<T> &Y) {
260   return Y && X < *Y;
261 }
262 
263 template <typename T> bool operator<=(const Optional<T> &X, const T &Y) {
264   return !(Y < X);
265 }
266 
267 template <typename T> bool operator<=(const T &X, const Optional<T> &Y) {
268   return !(Y < X);
269 }
270 
271 template <typename T> bool operator>(const Optional<T> &X, const T &Y) {
272   return Y < X;
273 }
274 
275 template <typename T> bool operator>(const T &X, const Optional<T> &Y) {
276   return Y < X;
277 }
278 
279 template <typename T> bool operator>=(const Optional<T> &X, const T &Y) {
280   return !(X < Y);
281 }
282 
283 template <typename T> bool operator>=(const T &X, const Optional<T> &Y) {
284   return !(X < Y);
285 }
286 
287 } // end llvm namespace
288 
289 #endif
290