[WinEH] Moved funclet pads should be in relative order
[oota-llvm.git] / include / llvm / ADT / Optional.h
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
35   Optional(NoneType) : hasVal(false) {}
36   explicit Optional() : hasVal(false) {}
37   Optional(const T &y) : hasVal(true) {
38     new (storage.buffer) T(y);
39   }
40   Optional(const Optional &O) : hasVal(O.hasVal) {
41     if (hasVal)
42       new (storage.buffer) T(*O);
43   }
44
45   Optional(T &&y) : hasVal(true) {
46     new (storage.buffer) T(std::forward<T>(y));
47   }
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>
75   void emplace(ArgTypes &&...Args) {
76     reset();
77     hasVal = true;
78     new (storage.buffer) T(std::forward<ArgTypes>(Args)...);
79   }
80
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
108   void reset() {
109     if (hasVal) {
110       (**this).~T();
111       hasVal = false;
112     }
113   }
114
115   ~Optional() {
116     reset();
117   }
118
119   const T* getPointer() const { assert(hasVal); return reinterpret_cast<const T*>(storage.buffer); }
120   T* getPointer() { assert(hasVal); return reinterpret_cast<T*>(storage.buffer); }
121   const T& getValue() const LLVM_LVALUE_FUNCTION { assert(hasVal); return *getPointer(); }
122   T& getValue() LLVM_LVALUE_FUNCTION { assert(hasVal); return *getPointer(); }
123
124   explicit operator bool() const { return hasVal; }
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>
132   LLVM_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
137   T&& getValue() && { assert(hasVal); return std::move(*getPointer()); }
138   T&& operator*() && { assert(hasVal); return std::move(*getPointer()); }
139
140   template <typename U>
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 /// \brief Poison comparison between two \c Optional objects. Clients needs to
154 /// explicitly compare the underlying values and account for empty \c Optional
155 /// objects.
156 ///
157 /// This routine will never be defined. It returns \c void to help diagnose
158 /// errors at compile time.
159 template<typename T, typename U>
160 void operator==(const Optional<T> &X, const Optional<U> &Y);
161
162 template<typename T>
163 bool operator==(const Optional<T> &X, NoneType) {
164   return !X.hasValue();
165 }
166
167 template<typename T>
168 bool operator==(NoneType, const Optional<T> &X) {
169   return X == None;
170 }
171
172 template<typename T>
173 bool operator!=(const Optional<T> &X, NoneType) {
174   return !(X == None);
175 }
176
177 template<typename T>
178 bool operator!=(NoneType, const Optional<T> &X) {
179   return X != None;
180 }
181 /// \brief Poison comparison between two \c Optional objects. Clients needs to
182 /// explicitly compare the underlying values and account for empty \c Optional
183 /// objects.
184 ///
185 /// This routine will never be defined. It returns \c void to help diagnose
186 /// errors at compile time.
187 template<typename T, typename U>
188 void operator!=(const Optional<T> &X, const Optional<U> &Y);
189
190 /// \brief Poison comparison between two \c Optional objects. Clients needs to
191 /// explicitly compare the underlying values and account for empty \c Optional
192 /// objects.
193 ///
194 /// This routine will never be defined. It returns \c void to help diagnose
195 /// errors at compile time.
196 template<typename T, typename U>
197 void operator<(const Optional<T> &X, const Optional<U> &Y);
198
199 /// \brief Poison comparison between two \c Optional objects. Clients needs to
200 /// explicitly compare the underlying values and account for empty \c Optional
201 /// objects.
202 ///
203 /// This routine will never be defined. It returns \c void to help diagnose
204 /// errors at compile time.
205 template<typename T, typename U>
206 void operator<=(const Optional<T> &X, const Optional<U> &Y);
207
208 /// \brief Poison comparison between two \c Optional objects. Clients needs to
209 /// explicitly compare the underlying values and account for empty \c Optional
210 /// objects.
211 ///
212 /// This routine will never be defined. It returns \c void to help diagnose
213 /// errors at compile time.
214 template<typename T, typename U>
215 void operator>=(const Optional<T> &X, const Optional<U> &Y);
216
217 /// \brief Poison comparison between two \c Optional objects. Clients needs to
218 /// explicitly compare the underlying values and account for empty \c Optional
219 /// objects.
220 ///
221 /// This routine will never be defined. It returns \c void to help diagnose
222 /// errors at compile time.
223 template<typename T, typename U>
224 void operator>(const Optional<T> &X, const Optional<U> &Y);
225
226 } // end llvm namespace
227
228 #endif