include/llvm/Support/ErrorOr.h

   1 //===- llvm/Support/ErrorOr.h - Error Smart Pointer -----------------------===//
   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_ERROR_OR_H
  17 #define LLVM_SUPPORT_ERROR_OR_H
  18
  19 #include "llvm/ADT/PointerIntPair.h"
  20 #include "llvm/Support/AlignOf.h"
  21 #include "llvm/Support/system_error.h"
  22 #include <cassert>
  23 #include <type_traits>
  24
  25 namespace llvm {
  26 template<class T, class V>
  27 typename std::enable_if< std::is_constructible<T, V>::value
  28                        , typename std::remove_reference<V>::type>::type &&
  29  moveIfMoveConstructible(V &Val) {
  30   return std::move(Val);
  31 }
  32
  33 template<class T, class V>
  34 typename std::enable_if< !std::is_constructible<T, V>::value
  35                        , typename std::remove_reference<V>::type>::type &
  36 moveIfMoveConstructible(V &Val) {
  37   return Val;
  38 }
  39
  40 /// \brief Stores a reference that can be changed.
  41 template <typename T>
  42 class ReferenceStorage {
  43   T *Storage;
  44
  45 public:
  46   ReferenceStorage(T &Ref) : Storage(&Ref) {}
  47
  48   operator T &() const { return *Storage; }
  49   T &get() const { return *Storage; }
  50 };
  51
  52 /// \brief Represents either an error or a value T.
  53 ///
  54 /// ErrorOr<T> is a pointer-like class that represents the result of an
  55 /// operation. The result is either an error, or a value of type T. This is
  56 /// designed to emulate the usage of returning a pointer where nullptr indicates
  57 /// failure. However instead of just knowing that the operation failed, we also
  58 /// have an error_code and optional user data that describes why it failed.
  59 ///
  60 /// It is used like the following.
  61 /// \code
  62 ///   ErrorOr<Buffer> getBuffer();
  63 ///
  64 ///   auto buffer = getBuffer();
  65 ///   if (error_code ec = buffer.getError())
  66 ///     return ec;
  67 ///   buffer->write("adena");
  68 /// \endcode
  69 ///
  70 ///
  71 /// An implicit conversion to bool provides a way to check if there was an
  72 /// error. The unary * and -> operators provide pointer like access to the
  73 /// value. Accessing the value when there is an error has undefined behavior.
  74 ///
  75 /// When T is a reference type the behaivor is slightly different. The reference
  76 /// is held in a std::reference_wrapper<std::remove_reference<T>::type>, and
  77 /// there is special handling to make operator -> work as if T was not a
  78 /// reference.
  79 ///
  80 /// T cannot be a rvalue reference.
  81 template<class T>
  82 class ErrorOr {
  83   template <class OtherT> friend class ErrorOr;
  84   static const bool isRef = std::is_reference<T>::value;
  85   typedef ReferenceStorage<typename std::remove_reference<T>::type> wrap;
  86
  87 public:
  88   typedef typename std::conditional<isRef, wrap, T>::type storage_type;
  89
  90 private:
  91   typedef typename std::remove_reference<T>::type &reference;
  92   typedef const typename std::remove_reference<T>::type &const_reference;
  93   typedef typename std::remove_reference<T>::type *pointer;
  94
  95 public:
  96   template <class E>
  97   ErrorOr(E ErrorCode, typename std::enable_if<is_error_code_enum<E>::value ||
  98                                                is_error_condition_enum<E>::value,
  99                                                void *>::type = 0)
 100       : HasError(true) {
 101     new (getErrorStorage()) error_code(make_error_code(ErrorCode));
 102   }
 103
 104   ErrorOr(llvm::error_code EC) : HasError(true) {
 105     new (getErrorStorage()) error_code(EC);
 106   }
 107
 108   ErrorOr(T Val) : HasError(false) {
 109     new (getStorage()) storage_type(moveIfMoveConstructible<storage_type>(Val));
 110   }
 111
 112   ErrorOr(const ErrorOr &Other) {
 113     copyConstruct(Other);
 114   }
 115
 116   template <class OtherT>
 117   ErrorOr(const ErrorOr<OtherT> &Other) {
 118     copyConstruct(Other);
 119   }
 120
 121   ErrorOr &operator =(const ErrorOr &Other) {
 122     copyAssign(Other);
 123     return *this;
 124   }
 125
 126   template <class OtherT>
 127   ErrorOr &operator =(const ErrorOr<OtherT> &Other) {
 128     copyAssign(Other);
 129     return *this;
 130   }
 131
 132   ErrorOr(ErrorOr &&Other) {
 133     moveConstruct(std::move(Other));
 134   }
 135
 136   template <class OtherT>
 137   ErrorOr(ErrorOr<OtherT> &&Other) {
 138     moveConstruct(std::move(Other));
 139   }
 140
 141   ErrorOr &operator =(ErrorOr &&Other) {
 142     moveAssign(std::move(Other));
 143     return *this;
 144   }
 145
 146   template <class OtherT>
 147   ErrorOr &operator =(ErrorOr<OtherT> &&Other) {
 148     moveAssign(std::move(Other));
 149     return *this;
 150   }
 151
 152   ~ErrorOr() {
 153     if (!HasError)
 154       getStorage()->~storage_type();
 155   }
 156
 157   /// \brief Return false if there is an error.
 158   LLVM_EXPLICIT operator bool() const {
 159     return !HasError;
 160   }
 161
 162   reference get() { return *getStorage(); }
 163   const_reference get() const { return const_cast<ErrorOr<T> >(this)->get(); }
 164
 165   error_code getError() const {
 166     return HasError ? *getErrorStorage() : error_code::success();
 167   }
 168
 169   pointer operator ->() {
 170     return toPointer(getStorage());
 171   }
 172
 173   reference operator *() {
 174     return *getStorage();
 175   }
 176
 177 private:
 178   template <class OtherT>
 179   void copyConstruct(const ErrorOr<OtherT> &Other) {
 180     if (!Other.HasError) {
 181       // Get the other value.
 182       HasError = false;
 183       new (getStorage()) storage_type(*Other.getStorage());
 184     } else {
 185       // Get other's error.
 186       HasError = true;
 187       new (getErrorStorage()) error_code(Other.getError());
 188     }
 189   }
 190
 191   template <class T1>
 192   static bool compareThisIfSameType(const T1 &a, const T1 &b) {
 193     return &a == &b;
 194   }
 195
 196   template <class T1, class T2>
 197   static bool compareThisIfSameType(const T1 &a, const T2 &b) {
 198     return false;
 199   }
 200
 201   template <class OtherT>
 202   void copyAssign(const ErrorOr<OtherT> &Other) {
 203     if (compareThisIfSameType(*this, Other))
 204       return;
 205
 206     this->~ErrorOr();
 207     new (this) ErrorOr(Other);
 208   }
 209
 210   template <class OtherT>
 211   void moveConstruct(ErrorOr<OtherT> &&Other) {
 212     if (!Other.HasError) {
 213       // Get the other value.
 214       HasError = false;
 215       new (getStorage()) storage_type(std::move(*Other.getStorage()));
 216     } else {
 217       // Get other's error.
 218       HasError = true;
 219       new (getErrorStorage()) error_code(Other.getError());
 220     }
 221   }
 222
 223   template <class OtherT>
 224   void moveAssign(ErrorOr<OtherT> &&Other) {
 225     if (compareThisIfSameType(*this, Other))
 226       return;
 227
 228     this->~ErrorOr();
 229     new (this) ErrorOr(std::move(Other));
 230   }
 231
 232   pointer toPointer(pointer Val) {
 233     return Val;
 234   }
 235
 236   pointer toPointer(wrap *Val) {
 237     return &Val->get();
 238   }
 239
 240   storage_type *getStorage() {
 241     assert(!HasError && "Cannot get value when an error exists!");
 242     return reinterpret_cast<storage_type*>(TStorage.buffer);
 243   }
 244
 245   const storage_type *getStorage() const {
 246     assert(!HasError && "Cannot get value when an error exists!");
 247     return reinterpret_cast<const storage_type*>(TStorage.buffer);
 248   }
 249
 250   error_code *getErrorStorage() {
 251     assert(HasError && "Cannot get error when a value exists!");
 252     return reinterpret_cast<error_code*>(ErrorStorage.buffer);
 253   }
 254
 255   const error_code *getErrorStorage() const {
 256     return const_cast<ErrorOr<T> *>(this)->getErrorStorage();
 257   }
 258
 259
 260   union {
 261     AlignedCharArrayUnion<storage_type> TStorage;
 262     AlignedCharArrayUnion<error_code> ErrorStorage;
 263   };
 264   bool HasError : 1;
 265 };
 266
 267 template<class T, class E>
 268 typename std::enable_if<is_error_code_enum<E>::value ||
 269                         is_error_condition_enum<E>::value, bool>::type
 270 operator ==(ErrorOr<T> &Err, E Code) {
 271   return error_code(Err) == Code;
 272 }
 273 } // end namespace llvm
 274
 275 #endif