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 Optional(NoneType)35 Optional(NoneType) : hasVal(false) {} Optional()36 explicit Optional() : hasVal(false) {} Optional(const T & y)37 Optional(const T &y) : hasVal(true) { 38 new (storage.buffer) T(y); 39 } Optional(const Optional & O)40 Optional(const Optional &O) : hasVal(O.hasVal) { 41 if (hasVal) 42 new (storage.buffer) T(*O); 43 } 44 Optional(T && y)45 Optional(T &&y) : hasVal(true) { 46 new (storage.buffer) T(std::forward<T>(y)); 47 } Optional(Optional<T> && O)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> emplace(ArgTypes &&...Args)75 void emplace(ArgTypes &&...Args) { 76 reset(); 77 hasVal = true; 78 new (storage.buffer) T(std::forward<ArgTypes>(Args)...); 79 } 80 create(const T * y)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 reset()108 void reset() { 109 if (hasVal) { 110 (**this).~T(); 111 hasVal = false; 112 } 113 } 114 ~Optional()115 ~Optional() { 116 reset(); 117 } 118 getPointer()119 const T* getPointer() const { assert(hasVal); return reinterpret_cast<const T*>(storage.buffer); } getPointer()120 T* getPointer() { assert(hasVal); return reinterpret_cast<T*>(storage.buffer); } getValue()121 const T& getValue() const LLVM_LVALUE_FUNCTION { assert(hasVal); return *getPointer(); } getValue()122 T& getValue() LLVM_LVALUE_FUNCTION { assert(hasVal); return *getPointer(); } 123 124 explicit operator bool() const { return hasVal; } hasValue()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> getValueOr(U && value)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 getValue()137 T&& getValue() && { assert(hasVal); return std::move(*getPointer()); } 138 T&& operator*() && { assert(hasVal); return std::move(*getPointer()); } 139 140 template <typename U> getValueOr(U && value)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 229