LLVM  6.0.0svn
ErrorOr.h
Go to the documentation of this file.
1 //===- llvm/Support/ErrorOr.h - Error Smart Pointer -------------*- C++ -*-===//
2 //
3 // The LLVM Linker
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 ///
10 /// \file
11 ///
12 /// Provides ErrorOr<T> smart pointer.
13 ///
14 //===----------------------------------------------------------------------===//
15 
16 #ifndef LLVM_SUPPORT_ERROROR_H
17 #define LLVM_SUPPORT_ERROROR_H
18 
19 #include "llvm/Support/AlignOf.h"
20 #include <cassert>
21 #include <system_error>
22 #include <type_traits>
23 #include <utility>
24 
25 namespace llvm {
26 
27 /// \brief Stores a reference that can be changed.
28 template <typename T>
30  T *Storage;
31 
32 public:
33  ReferenceStorage(T &Ref) : Storage(&Ref) {}
34 
35  operator T &() const { return *Storage; }
36  T &get() const { return *Storage; }
37 };
38 
39 /// \brief Represents either an error or a value T.
40 ///
41 /// ErrorOr<T> is a pointer-like class that represents the result of an
42 /// operation. The result is either an error, or a value of type T. This is
43 /// designed to emulate the usage of returning a pointer where nullptr indicates
44 /// failure. However instead of just knowing that the operation failed, we also
45 /// have an error_code and optional user data that describes why it failed.
46 ///
47 /// It is used like the following.
48 /// \code
49 /// ErrorOr<Buffer> getBuffer();
50 ///
51 /// auto buffer = getBuffer();
52 /// if (error_code ec = buffer.getError())
53 /// return ec;
54 /// buffer->write("adena");
55 /// \endcode
56 ///
57 ///
58 /// Implicit conversion to bool returns true if there is a usable value. The
59 /// unary * and -> operators provide pointer like access to the value. Accessing
60 /// the value when there is an error has undefined behavior.
61 ///
62 /// When T is a reference type the behavior is slightly different. The reference
63 /// is held in a std::reference_wrapper<std::remove_reference<T>::type>, and
64 /// there is special handling to make operator -> work as if T was not a
65 /// reference.
66 ///
67 /// T cannot be a rvalue reference.
68 template<class T>
69 class ErrorOr {
70  template <class OtherT> friend class ErrorOr;
71 
72  static const bool isRef = std::is_reference<T>::value;
73 
75 
76 public:
77  using storage_type = typename std::conditional<isRef, wrap, T>::type;
78 
79 private:
80  using reference = typename std::remove_reference<T>::type &;
81  using const_reference = const typename std::remove_reference<T>::type &;
82  using pointer = typename std::remove_reference<T>::type *;
83  using const_pointer = const typename std::remove_reference<T>::type *;
84 
85 public:
86  template <class E>
87  ErrorOr(E ErrorCode,
88  typename std::enable_if<std::is_error_code_enum<E>::value ||
89  std::is_error_condition_enum<E>::value,
90  void *>::type = nullptr)
91  : HasError(true) {
92  new (getErrorStorage()) std::error_code(make_error_code(ErrorCode));
93  }
94 
95  ErrorOr(std::error_code EC) : HasError(true) {
96  new (getErrorStorage()) std::error_code(EC);
97  }
98 
99  template <class OtherT>
100  ErrorOr(OtherT &&Val,
101  typename std::enable_if<std::is_convertible<OtherT, T>::value>::type
102  * = nullptr)
103  : HasError(false) {
104  new (getStorage()) storage_type(std::forward<OtherT>(Val));
105  }
106 
108  copyConstruct(Other);
109  }
110 
111  template <class OtherT>
113  const ErrorOr<OtherT> &Other,
114  typename std::enable_if<std::is_convertible<OtherT, T>::value>::type * =
115  nullptr) {
116  copyConstruct(Other);
117  }
118 
119  template <class OtherT>
120  explicit ErrorOr(
121  const ErrorOr<OtherT> &Other,
122  typename std::enable_if<
123  !std::is_convertible<OtherT, const T &>::value>::type * = nullptr) {
124  copyConstruct(Other);
125  }
126 
128  moveConstruct(std::move(Other));
129  }
130 
131  template <class OtherT>
134  typename std::enable_if<std::is_convertible<OtherT, T>::value>::type * =
135  nullptr) {
136  moveConstruct(std::move(Other));
137  }
138 
139  // This might eventually need SFINAE but it's more complex than is_convertible
140  // & I'm too lazy to write it right now.
141  template <class OtherT>
142  explicit ErrorOr(
144  typename std::enable_if<!std::is_convertible<OtherT, T>::value>::type * =
145  nullptr) {
146  moveConstruct(std::move(Other));
147  }
148 
150  copyAssign(Other);
151  return *this;
152  }
153 
155  moveAssign(std::move(Other));
156  return *this;
157  }
158 
160  if (!HasError)
161  getStorage()->~storage_type();
162  }
163 
164  /// \brief Return false if there is an error.
165  explicit operator bool() const {
166  return !HasError;
167  }
168 
169  reference get() { return *getStorage(); }
170  const_reference get() const { return const_cast<ErrorOr<T> *>(this)->get(); }
171 
172  std::error_code getError() const {
173  return HasError ? *getErrorStorage() : std::error_code();
174  }
175 
176  pointer operator ->() {
177  return toPointer(getStorage());
178  }
179 
180  const_pointer operator->() const { return toPointer(getStorage()); }
181 
182  reference operator *() {
183  return *getStorage();
184  }
185 
186  const_reference operator*() const { return *getStorage(); }
187 
188 private:
189  template <class OtherT>
190  void copyConstruct(const ErrorOr<OtherT> &Other) {
191  if (!Other.HasError) {
192  // Get the other value.
193  HasError = false;
194  new (getStorage()) storage_type(*Other.getStorage());
195  } else {
196  // Get other's error.
197  HasError = true;
198  new (getErrorStorage()) std::error_code(Other.getError());
199  }
200  }
201 
202  template <class T1>
203  static bool compareThisIfSameType(const T1 &a, const T1 &b) {
204  return &a == &b;
205  }
206 
207  template <class T1, class T2>
208  static bool compareThisIfSameType(const T1 &a, const T2 &b) {
209  return false;
210  }
211 
212  template <class OtherT>
213  void copyAssign(const ErrorOr<OtherT> &Other) {
214  if (compareThisIfSameType(*this, Other))
215  return;
216 
217  this->~ErrorOr();
218  new (this) ErrorOr(Other);
219  }
220 
221  template <class OtherT>
222  void moveConstruct(ErrorOr<OtherT> &&Other) {
223  if (!Other.HasError) {
224  // Get the other value.
225  HasError = false;
226  new (getStorage()) storage_type(std::move(*Other.getStorage()));
227  } else {
228  // Get other's error.
229  HasError = true;
230  new (getErrorStorage()) std::error_code(Other.getError());
231  }
232  }
233 
234  template <class OtherT>
235  void moveAssign(ErrorOr<OtherT> &&Other) {
236  if (compareThisIfSameType(*this, Other))
237  return;
238 
239  this->~ErrorOr();
240  new (this) ErrorOr(std::move(Other));
241  }
242 
243  pointer toPointer(pointer Val) {
244  return Val;
245  }
246 
247  const_pointer toPointer(const_pointer Val) const { return Val; }
248 
249  pointer toPointer(wrap *Val) {
250  return &Val->get();
251  }
252 
253  const_pointer toPointer(const wrap *Val) const { return &Val->get(); }
254 
255  storage_type *getStorage() {
256  assert(!HasError && "Cannot get value when an error exists!");
257  return reinterpret_cast<storage_type*>(TStorage.buffer);
258  }
259 
260  const storage_type *getStorage() const {
261  assert(!HasError && "Cannot get value when an error exists!");
262  return reinterpret_cast<const storage_type*>(TStorage.buffer);
263  }
264 
265  std::error_code *getErrorStorage() {
266  assert(HasError && "Cannot get error when a value exists!");
267  return reinterpret_cast<std::error_code *>(ErrorStorage.buffer);
268  }
269 
270  const std::error_code *getErrorStorage() const {
271  return const_cast<ErrorOr<T> *>(this)->getErrorStorage();
272  }
273 
274  union {
277  };
278  bool HasError : 1;
279 };
280 
281 template <class T, class E>
282 typename std::enable_if<std::is_error_code_enum<E>::value ||
283  std::is_error_condition_enum<E>::value,
284  bool>::type
285 operator==(const ErrorOr<T> &Err, E Code) {
286  return Err.getError() == Code;
287 }
288 
289 } // end namespace llvm
290 
291 #endif // LLVM_SUPPORT_ERROROR_H
ErrorOr(const ErrorOr< OtherT > &Other, typename std::enable_if< std::is_convertible< OtherT, T >::value >::type *=nullptr)
Definition: ErrorOr.h:112
Represents either an error or a value T.
Definition: ErrorOr.h:69
ErrorOr & operator=(const ErrorOr &Other)
Definition: ErrorOr.h:149
Compute iterated dominance frontiers using a linear time algorithm.
Definition: AllocatorList.h:24
ErrorOr(OtherT &&Val, typename std::enable_if< std::is_convertible< OtherT, T >::value >::type *=nullptr)
Definition: ErrorOr.h:100
typename std::conditional< isRef, wrap, T >::type storage_type
Definition: ErrorOr.h:77
ErrorOr(const ErrorOr< OtherT > &Other, typename std::enable_if< !std::is_convertible< OtherT, const T &>::value >::type *=nullptr)
Definition: ErrorOr.h:120
std::error_code make_error_code(BitcodeError E)
ELFYAML::ELF_STO Other
Definition: ELFYAML.cpp:736
APInt operator*(APInt a, uint64_t RHS)
Definition: APInt.h:2070
const_pointer operator->() const
Definition: ErrorOr.h:180
AlignedCharArrayUnion< std::error_code > ErrorStorage
Definition: ErrorOr.h:276
ReferenceStorage(T &Ref)
Definition: ErrorOr.h:33
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
ErrorOr(const ErrorOr &Other)
Definition: ErrorOr.h:107
std::error_code getError() const
Definition: ErrorOr.h:172
AlignedCharArrayUnion< storage_type > TStorage
Definition: ErrorOr.h:275
ErrorOr(E ErrorCode, typename std::enable_if< std::is_error_code_enum< E >::value||std::is_error_condition_enum< E >::value, void *>::type=nullptr)
Definition: ErrorOr.h:87
ErrorOr(ErrorOr< OtherT > &&Other, typename std::enable_if<!std::is_convertible< OtherT, T >::value >::type *=nullptr)
Definition: ErrorOr.h:142
T & get() const
Definition: ErrorOr.h:36
ErrorOr(std::error_code EC)
Definition: ErrorOr.h:95
ErrorOr(ErrorOr< OtherT > &&Other, typename std::enable_if< std::is_convertible< OtherT, T >::value >::type *=nullptr)
Definition: ErrorOr.h:132
const_reference operator*() const
Definition: ErrorOr.h:186
Basic Alias true
ErrorOr(ErrorOr &&Other)
Definition: ErrorOr.h:127
Stores a reference that can be changed.
Definition: ErrorOr.h:29
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
ErrorOr & operator=(ErrorOr &&Other)
Definition: ErrorOr.h:154
bool operator==(uint64_t V1, const APInt &V2)
Definition: APInt.h:1946
#define T1