include/llvm/ADT/Optional.h

   1 //===- Optional.h - Simple variant for passing optional values --*- C++ -*-===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8 //
   9 //  This file provides Optional, a template class modeled in the spirit of
  10 //  OCaml's 'opt' variant.  The idea is to strongly type whether or not
  11 //  a value can be optional.
  12 //
  13 //===----------------------------------------------------------------------===//
  14
  15 #ifndef LLVM_ADT_OPTIONAL_H
  16 #define LLVM_ADT_OPTIONAL_H
  17
  18 #include "llvm/ADT/None.h"
  19 #include "llvm/Support/AlignOf.h"
  20 #include "llvm/Support/Compiler.h"
  21 #include "llvm/Support/type_traits.h"
  22 #include <algorithm>
  23 #include <cassert>
  24 #include <new>
  25 #include <utility>
  26
  27 namespace llvm {
  28
  29 class raw_ostream;
  30
  31 namespace optional_detail {
  32
  33 struct in_place_t {};
  34
  35 /// Storage for any type.
  36 template <typename T, bool = is_trivially_copyable<T>::value>
  37 class OptionalStorage {
  38   union {
  39     char empty;
  40     T value;
  41   };
  42   bool hasVal;
  43
  44 public:
  45   ~OptionalStorage() { reset(); }
  46
  47   OptionalStorage() noexcept : empty(), hasVal(false) {}
  48
  49   OptionalStorage(OptionalStorage const &other) : OptionalStorage() {
  50     if (other.hasValue()) {
  51       emplace(other.value);
  52     }
  53   }
  54   OptionalStorage(OptionalStorage &&other) : OptionalStorage() {
  55     if (other.hasValue()) {
  56       emplace(std::move(other.value));
  57     }
  58   }
  59
  60   template <class... Args>
  61   explicit OptionalStorage(in_place_t, Args &&... args)
  62       : value(std::forward<Args>(args)...), hasVal(true) {}
  63
  64   void reset() noexcept {
  65     if (hasVal) {
  66       value.~T();
  67       hasVal = false;
  68     }
  69   }
  70
  71   bool hasValue() const noexcept { return hasVal; }
  72
  73   T &getValue() LLVM_LVALUE_FUNCTION noexcept {
  74     assert(hasVal);
  75     return value;
  76   }
  77   T const &getValue() const LLVM_LVALUE_FUNCTION noexcept {
  78     assert(hasVal);
  79     return value;
  80   }
  81 #if LLVM_HAS_RVALUE_REFERENCE_THIS
  82   T &&getValue() && noexcept {
  83     assert(hasVal);
  84     return std::move(value);
  85   }
  86 #endif
  87
  88   template <class... Args> void emplace(Args &&... args) {
  89     reset();
  90     ::new ((void *)std::addressof(value)) T(std::forward<Args>(args)...);
  91     hasVal = true;
  92   }
  93
  94   OptionalStorage &operator=(T const &y) {
  95     if (hasValue()) {
  96       value = y;
  97     } else {
  98       ::new ((void *)std::addressof(value)) T(y);
  99       hasVal = true;
 100     }
 101     return *this;
 102   }
 103   OptionalStorage &operator=(T &&y) {
 104     if (hasValue()) {
 105       value = std::move(y);
 106     } else {
 107       ::new ((void *)std::addressof(value)) T(std::move(y));
 108       hasVal = true;
 109     }
 110     return *this;
 111   }
 112
 113   OptionalStorage &operator=(OptionalStorage const &other) {
 114     if (other.hasValue()) {
 115       if (hasValue()) {
 116         value = other.value;
 117       } else {
 118         ::new ((void *)std::addressof(value)) T(other.value);
 119         hasVal = true;
 120       }
 121     } else {
 122       reset();
 123     }
 124     return *this;
 125   }
 126
 127   OptionalStorage &operator=(OptionalStorage &&other) {
 128     if (other.hasValue()) {
 129       if (hasValue()) {
 130         value = std::move(other.value);
 131       } else {
 132         ::new ((void *)std::addressof(value)) T(std::move(other.value));
 133         hasVal = true;
 134       }
 135     } else {
 136       reset();
 137     }
 138     return *this;
 139   }
 140 };
 141
 142 } // namespace optional_detail
 143
 144 template <typename T> class Optional {
 145   optional_detail::OptionalStorage<T> Storage;
 146
 147 public:
 148   using value_type = T;
 149
 150   constexpr Optional() {}
 151   constexpr Optional(NoneType) {}
 152
 153   Optional(const T &y) : Storage(optional_detail::in_place_t{}, y) {}
 154   Optional(const Optional &O) = default;
 155
 156   Optional(T &&y) : Storage(optional_detail::in_place_t{}, std::move(y)) {}
 157   Optional(Optional &&O) = default;
 158
 159   Optional &operator=(T &&y) {
 160     Storage = std::move(y);
 161     return *this;
 162   }
 163   Optional &operator=(Optional &&O) = default;
 164
 165   /// Create a new object by constructing it in place with the given arguments.
 166   template <typename... ArgTypes> void emplace(ArgTypes &&... Args) {
 167     Storage.emplace(std::forward<ArgTypes>(Args)...);
 168   }
 169
 170   static inline Optional create(const T *y) {
 171     return y ? Optional(*y) : Optional();
 172   }
 173
 174   Optional &operator=(const T &y) {
 175     Storage = y;
 176     return *this;
 177   }
 178   Optional &operator=(const Optional &O) = default;
 179
 180   void reset() { Storage.reset(); }
 181
 182   const T *getPointer() const { return &Storage.getValue(); }
 183   T *getPointer() { return &Storage.getValue(); }
 184   const T &getValue() const LLVM_LVALUE_FUNCTION { return Storage.getValue(); }
 185   T &getValue() LLVM_LVALUE_FUNCTION { return Storage.getValue(); }
 186
 187   explicit operator bool() const { return hasValue(); }
 188   bool hasValue() const { return Storage.hasValue(); }
 189   const T *operator->() const { return getPointer(); }
 190   T *operator->() { return getPointer(); }
 191   const T &operator*() const LLVM_LVALUE_FUNCTION { return getValue(); }
 192   T &operator*() LLVM_LVALUE_FUNCTION { return getValue(); }
 193
 194   template <typename U>
 195   constexpr T getValueOr(U &&value) const LLVM_LVALUE_FUNCTION {
 196     return hasValue() ? getValue() : std::forward<U>(value);
 197   }
 198
 199 #if LLVM_HAS_RVALUE_REFERENCE_THIS
 200   T &&getValue() && { return std::move(Storage.getValue()); }
 201   T &&operator*() && { return std::move(Storage.getValue()); }
 202
 203   template <typename U>
 204   T getValueOr(U &&value) && {
 205     return hasValue() ? std::move(getValue()) : std::forward<U>(value);
 206   }
 207 #endif
 208 };
 209
 210 template <typename T, typename U>
 211 bool operator==(const Optional<T> &X, const Optional<U> &Y) {
 212   if (X && Y)
 213     return *X == *Y;
 214   return X.hasValue() == Y.hasValue();
 215 }
 216
 217 template <typename T, typename U>
 218 bool operator!=(const Optional<T> &X, const Optional<U> &Y) {
 219   return !(X == Y);
 220 }
 221
 222 template <typename T, typename U>
 223 bool operator<(const Optional<T> &X, const Optional<U> &Y) {
 224   if (X && Y)
 225     return *X < *Y;
 226   return X.hasValue() < Y.hasValue();
 227 }
 228
 229 template <typename T, typename U>
 230 bool operator<=(const Optional<T> &X, const Optional<U> &Y) {
 231   return !(Y < X);
 232 }
 233
 234 template <typename T, typename U>
 235 bool operator>(const Optional<T> &X, const Optional<U> &Y) {
 236   return Y < X;
 237 }
 238
 239 template <typename T, typename U>
 240 bool operator>=(const Optional<T> &X, const Optional<U> &Y) {
 241   return !(X < Y);
 242 }
 243
 244 template<typename T>
 245 bool operator==(const Optional<T> &X, NoneType) {
 246   return !X;
 247 }
 248
 249 template<typename T>
 250 bool operator==(NoneType, const Optional<T> &X) {
 251   return X == None;
 252 }
 253
 254 template<typename T>
 255 bool operator!=(const Optional<T> &X, NoneType) {
 256   return !(X == None);
 257 }
 258
 259 template<typename T>
 260 bool operator!=(NoneType, const Optional<T> &X) {
 261   return X != None;
 262 }
 263
 264 template <typename T> bool operator<(const Optional<T> &X, NoneType) {
 265   return false;
 266 }
 267
 268 template <typename T> bool operator<(NoneType, const Optional<T> &X) {
 269   return X.hasValue();
 270 }
 271
 272 template <typename T> bool operator<=(const Optional<T> &X, NoneType) {
 273   return !(None < X);
 274 }
 275
 276 template <typename T> bool operator<=(NoneType, const Optional<T> &X) {
 277   return !(X < None);
 278 }
 279
 280 template <typename T> bool operator>(const Optional<T> &X, NoneType) {
 281   return None < X;
 282 }
 283
 284 template <typename T> bool operator>(NoneType, const Optional<T> &X) {
 285   return X < None;
 286 }
 287
 288 template <typename T> bool operator>=(const Optional<T> &X, NoneType) {
 289   return None <= X;
 290 }
 291
 292 template <typename T> bool operator>=(NoneType, const Optional<T> &X) {
 293   return X <= None;
 294 }
 295
 296 template <typename T> bool operator==(const Optional<T> &X, const T &Y) {
 297   return X && *X == Y;
 298 }
 299
 300 template <typename T> bool operator==(const T &X, const Optional<T> &Y) {
 301   return Y && X == *Y;
 302 }
 303
 304 template <typename T> bool operator!=(const Optional<T> &X, const T &Y) {
 305   return !(X == Y);
 306 }
 307
 308 template <typename T> bool operator!=(const T &X, const Optional<T> &Y) {
 309   return !(X == Y);
 310 }
 311
 312 template <typename T> bool operator<(const Optional<T> &X, const T &Y) {
 313   return !X || *X < Y;
 314 }
 315
 316 template <typename T> bool operator<(const T &X, const Optional<T> &Y) {
 317   return Y && X < *Y;
 318 }
 319
 320 template <typename T> bool operator<=(const Optional<T> &X, const T &Y) {
 321   return !(Y < X);
 322 }
 323
 324 template <typename T> bool operator<=(const T &X, const Optional<T> &Y) {
 325   return !(Y < X);
 326 }
 327
 328 template <typename T> bool operator>(const Optional<T> &X, const T &Y) {
 329   return Y < X;
 330 }
 331
 332 template <typename T> bool operator>(const T &X, const Optional<T> &Y) {
 333   return Y < X;
 334 }
 335
 336 template <typename T> bool operator>=(const Optional<T> &X, const T &Y) {
 337   return !(X < Y);
 338 }
 339
 340 template <typename T> bool operator>=(const T &X, const Optional<T> &Y) {
 341   return !(X < Y);
 342 }
 343
 344 raw_ostream &operator<<(raw_ostream &OS, NoneType);
 345
 346 template <typename T, typename = decltype(std::declval<raw_ostream &>()
 347                                           << std::declval<const T &>())>
 348 raw_ostream &operator<<(raw_ostream &OS, const Optional<T> &O) {
 349   if (O)
 350     OS << *O;
 351   else
 352     OS << None;
 353   return OS;
 354 }
 355
 356 } // end namespace llvm
 357
 358 #endif // LLVM_ADT_OPTIONAL_H