contrib/llvm/include/llvm/ADT/Any.h

   1 //===- Any.h - Generic type erased holder of any type -----------*- 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 Any, a non-template class modeled in the spirit of
  11 //  std::any.  The idea is to provide a type-safe replacement for C's void*.
  12 //  It can hold a value of any copy-constructible copy-assignable type
  13 //
  14 //===----------------------------------------------------------------------===//
  15
  16 #ifndef LLVM_ADT_ANY_H
  17 #define LLVM_ADT_ANY_H
  18
  19 #include "llvm/ADT/STLExtras.h"
  20
  21 #include <cassert>
  22 #include <memory>
  23 #include <type_traits>
  24
  25 namespace llvm {
  26
  27 class Any {
  28   template <typename T> struct TypeId { static const char Id; };
  29
  30   struct StorageBase {
  31     virtual ~StorageBase() = default;
  32     virtual std::unique_ptr<StorageBase> clone() const = 0;
  33     virtual const void *id() const = 0;
  34   };
  35
  36   template <typename T> struct StorageImpl : public StorageBase {
  37     explicit StorageImpl(const T &Value) : Value(Value) {}
  38
  39     explicit StorageImpl(T &&Value) : Value(std::move(Value)) {}
  40
  41     std::unique_ptr<StorageBase> clone() const override {
  42       return llvm::make_unique<StorageImpl<T>>(Value);
  43     }
  44
  45     const void *id() const override { return &TypeId<T>::Id; }
  46
  47     T Value;
  48
  49   private:
  50     StorageImpl &operator=(const StorageImpl &Other) = delete;
  51     StorageImpl(const StorageImpl &Other) = delete;
  52   };
  53
  54 public:
  55   Any() = default;
  56
  57   Any(const Any &Other)
  58       : Storage(Other.Storage ? Other.Storage->clone() : nullptr) {}
  59
  60   // When T is Any or T is not copy-constructible we need to explicitly disable
  61   // the forwarding constructor so that the copy constructor gets selected
  62   // instead.
  63   template <
  64       typename T,
  65       typename std::enable_if<
  66           llvm::conjunction<
  67               llvm::negation<std::is_same<typename std::decay<T>::type, Any>>,
  68               std::is_copy_constructible<typename std::decay<T>::type>>::value,
  69           int>::type = 0>
  70   Any(T &&Value) {
  71     using U = typename std::decay<T>::type;
  72     Storage = llvm::make_unique<StorageImpl<U>>(std::forward<T>(Value));
  73   }
  74
  75   Any(Any &&Other) : Storage(std::move(Other.Storage)) {}
  76
  77   Any &swap(Any &Other) {
  78     std::swap(Storage, Other.Storage);
  79     return *this;
  80   }
  81
  82   Any &operator=(Any Other) {
  83     Storage = std::move(Other.Storage);
  84     return *this;
  85   }
  86
  87   bool hasValue() const { return !!Storage; }
  88
  89   void reset() { Storage.reset(); }
  90
  91 private:
  92   template <class T> friend T any_cast(const Any &Value);
  93   template <class T> friend T any_cast(Any &Value);
  94   template <class T> friend T any_cast(Any &&Value);
  95   template <class T> friend const T *any_cast(const Any *Value);
  96   template <class T> friend T *any_cast(Any *Value);
  97   template <typename T> friend bool any_isa(const Any &Value);
  98
  99   std::unique_ptr<StorageBase> Storage;
 100 };
 101
 102 template <typename T> const char Any::TypeId<T>::Id = 0;
 103
 104
 105 template <typename T> bool any_isa(const Any &Value) {
 106   if (!Value.Storage)
 107     return false;
 108   using U =
 109       typename std::remove_cv<typename std::remove_reference<T>::type>::type;
 110   return Value.Storage->id() == &Any::TypeId<U>::Id;
 111 }
 112
 113 template <class T> T any_cast(const Any &Value) {
 114   using U =
 115       typename std::remove_cv<typename std::remove_reference<T>::type>::type;
 116   return static_cast<T>(*any_cast<U>(&Value));
 117 }
 118
 119 template <class T> T any_cast(Any &Value) {
 120   using U =
 121       typename std::remove_cv<typename std::remove_reference<T>::type>::type;
 122   return static_cast<T>(*any_cast<U>(&Value));
 123 }
 124
 125 template <class T> T any_cast(Any &&Value) {
 126   using U =
 127       typename std::remove_cv<typename std::remove_reference<T>::type>::type;
 128   return static_cast<T>(std::move(*any_cast<U>(&Value)));
 129 }
 130
 131 template <class T> const T *any_cast(const Any *Value) {
 132   using U =
 133       typename std::remove_cv<typename std::remove_reference<T>::type>::type;
 134   assert(Value && any_isa<T>(*Value) && "Bad any cast!");
 135   if (!Value || !any_isa<U>(*Value))
 136     return nullptr;
 137   return &static_cast<Any::StorageImpl<U> &>(*Value->Storage).Value;
 138 }
 139
 140 template <class T> T *any_cast(Any *Value) {
 141   using U = typename std::decay<T>::type;
 142   assert(Value && any_isa<U>(*Value) && "Bad any cast!");
 143   if (!Value || !any_isa<U>(*Value))
 144     return nullptr;
 145   return &static_cast<Any::StorageImpl<U> &>(*Value->Storage).Value;
 146 }
 147
 148 } // end namespace llvm
 149
 150 #endif // LLVM_ADT_ANY_H