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
  17 #define LLVM_ADT_OPTIONAL
  18
  19 #include "LLVM/Support/Compiler.h"
  20 #include <cassert>
  21
  22 #if LLVM_USE_RVALUE_REFERENCES
  23 #include <utility>
  24 #endif
  25
  26 namespace llvm {
  27
  28 template<typename T>
  29 class Optional {
  30   T x;
  31   unsigned hasVal : 1;
  32 public:
  33   explicit Optional() : x(), hasVal(false) {}
  34   Optional(const T &y) : x(y), hasVal(true) {}
  35
  36 #if LLVM_USE_RVALUE_REFERENCES
  37   Optional(T &&y) : x(std::forward<T>(y)), hasVal(true) {}
  38 #endif
  39
  40   static inline Optional create(const T* y) {
  41     return y ? Optional(*y) : Optional();
  42   }
  43
  44   Optional &operator=(const T &y) {
  45     x = y;
  46     hasVal = true;
  47     return *this;
  48   }
  49
  50   const T* getPointer() const { assert(hasVal); return &x; }
  51   const T& getValue() const { assert(hasVal); return x; }
  52
  53   operator bool() const { return hasVal; }
  54   bool hasValue() const { return hasVal; }
  55   const T* operator->() const { return getPointer(); }
  56   const T& operator*() const { assert(hasVal); return x; }
  57 };
  58
  59 template<typename T> struct simplify_type;
  60
  61 template <typename T>
  62 struct simplify_type<const Optional<T> > {
  63   typedef const T* SimpleType;
  64   static SimpleType getSimplifiedValue(const Optional<T> &Val) {
  65     return Val.getPointer();
  66   }
  67 };
  68
  69 template <typename T>
  70 struct simplify_type<Optional<T> >
  71   : public simplify_type<const Optional<T> > {};
  72
  73 /// \brief Poison comparison between two \c Optional objects. Clients needs to
  74 /// explicitly compare the underlying values and account for empty \c Optional
  75 /// objects.
  76 ///
  77 /// This routine will never be defined. It returns \c void to help diagnose
  78 /// errors at compile time.
  79 template<typename T, typename U>
  80 void operator==(const Optional<T> &X, const Optional<U> &Y);
  81
  82 /// \brief Poison comparison between two \c Optional objects. Clients needs to
  83 /// explicitly compare the underlying values and account for empty \c Optional
  84 /// objects.
  85 ///
  86 /// This routine will never be defined. It returns \c void to help diagnose
  87 /// errors at compile time.
  88 template<typename T, typename U>
  89 void operator!=(const Optional<T> &X, const Optional<U> &Y);
  90
  91 /// \brief Poison comparison between two \c Optional objects. Clients needs to
  92 /// explicitly compare the underlying values and account for empty \c Optional
  93 /// objects.
  94 ///
  95 /// This routine will never be defined. It returns \c void to help diagnose
  96 /// errors at compile time.
  97 template<typename T, typename U>
  98 void operator<(const Optional<T> &X, const Optional<U> &Y);
  99
 100 /// \brief Poison comparison between two \c Optional objects. Clients needs to
 101 /// explicitly compare the underlying values and account for empty \c Optional
 102 /// objects.
 103 ///
 104 /// This routine will never be defined. It returns \c void to help diagnose
 105 /// errors at compile time.
 106 template<typename T, typename U>
 107 void operator<=(const Optional<T> &X, const Optional<U> &Y);
 108
 109 /// \brief Poison comparison between two \c Optional objects. Clients needs to
 110 /// explicitly compare the underlying values and account for empty \c Optional
 111 /// objects.
 112 ///
 113 /// This routine will never be defined. It returns \c void to help diagnose
 114 /// errors at compile time.
 115 template<typename T, typename U>
 116 void operator>=(const Optional<T> &X, const Optional<U> &Y);
 117
 118 /// \brief Poison comparison between two \c Optional objects. Clients needs to
 119 /// explicitly compare the underlying values and account for empty \c Optional
 120 /// objects.
 121 ///
 122 /// This routine will never be defined. It returns \c void to help diagnose
 123 /// errors at compile time.
 124 template<typename T, typename U>
 125 void operator>(const Optional<T> &X, const Optional<U> &Y);
 126
 127 } // end llvm namespace
 128
 129 #endif