contrib/llvm/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   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 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