1 //===- Any.h - Generic type erased holder of any type -----------*- 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 /// \file 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/STLForwardCompat.h" 20 #include "llvm/Support/Compiler.h" 21 22 #include <cassert> 23 #include <memory> 24 #include <type_traits> 25 26 namespace llvm { 27 28 class LLVM_EXTERNAL_VISIBILITY Any { 29 30 // The `Typeid<T>::Id` static data member below is a globally unique 31 // identifier for the type `T`. It is explicitly marked with default 32 // visibility so that when `-fvisibility=hidden` is used, the loader still 33 // merges duplicate definitions across DSO boundaries. 34 template <typename T> struct TypeId { static const char Id; }; 35 36 struct StorageBase { 37 virtual ~StorageBase() = default; 38 virtual std::unique_ptr<StorageBase> clone() const = 0; 39 virtual const void *id() const = 0; 40 }; 41 42 template <typename T> struct StorageImpl : public StorageBase { 43 explicit StorageImpl(const T &Value) : Value(Value) {} 44 45 explicit StorageImpl(T &&Value) : Value(std::move(Value)) {} 46 47 std::unique_ptr<StorageBase> clone() const override { 48 return std::make_unique<StorageImpl<T>>(Value); 49 } 50 51 const void *id() const override { return &TypeId<T>::Id; } 52 53 T Value; 54 55 private: 56 StorageImpl &operator=(const StorageImpl &Other) = delete; 57 StorageImpl(const StorageImpl &Other) = delete; 58 }; 59 60 public: 61 Any() = default; 62 63 Any(const Any &Other) 64 : Storage(Other.Storage ? Other.Storage->clone() : nullptr) {} 65 66 // When T is Any or T is not copy-constructible we need to explicitly disable 67 // the forwarding constructor so that the copy constructor gets selected 68 // instead. 69 template <typename T, 70 std::enable_if_t< 71 llvm::conjunction< 72 llvm::negation<std::is_same<std::decay_t<T>, Any>>, 73 // We also disable this overload when an `Any` object can be 74 // converted to the parameter type because in that case, 75 // this constructor may combine with that conversion during 76 // overload resolution for determining copy 77 // constructibility, and then when we try to determine copy 78 // constructibility below we may infinitely recurse. This is 79 // being evaluated by the standards committee as a potential 80 // DR in `std::any` as well, but we're going ahead and 81 // adopting it to work-around usage of `Any` with types that 82 // need to be implicitly convertible from an `Any`. 83 llvm::negation<std::is_convertible<Any, std::decay_t<T>>>, 84 std::is_copy_constructible<std::decay_t<T>>>::value, 85 int> = 0> 86 Any(T &&Value) { 87 Storage = 88 std::make_unique<StorageImpl<std::decay_t<T>>>(std::forward<T>(Value)); 89 } 90 91 Any(Any &&Other) : Storage(std::move(Other.Storage)) {} 92 93 Any &swap(Any &Other) { 94 std::swap(Storage, Other.Storage); 95 return *this; 96 } 97 98 Any &operator=(Any Other) { 99 Storage = std::move(Other.Storage); 100 return *this; 101 } 102 103 bool hasValue() const { return !!Storage; } 104 105 void reset() { Storage.reset(); } 106 107 private: 108 template <class T> friend T any_cast(const Any &Value); 109 template <class T> friend T any_cast(Any &Value); 110 template <class T> friend T any_cast(Any &&Value); 111 template <class T> friend const T *any_cast(const Any *Value); 112 template <class T> friend T *any_cast(Any *Value); 113 template <typename T> friend bool any_isa(const Any &Value); 114 115 std::unique_ptr<StorageBase> Storage; 116 }; 117 118 template <typename T> const char Any::TypeId<T>::Id = 0; 119 120 121 template <typename T> bool any_isa(const Any &Value) { 122 if (!Value.Storage) 123 return false; 124 return Value.Storage->id() == &Any::TypeId<remove_cvref_t<T>>::Id; 125 } 126 127 template <class T> T any_cast(const Any &Value) { 128 return static_cast<T>(*any_cast<remove_cvref_t<T>>(&Value)); 129 } 130 131 template <class T> T any_cast(Any &Value) { 132 return static_cast<T>(*any_cast<remove_cvref_t<T>>(&Value)); 133 } 134 135 template <class T> T any_cast(Any &&Value) { 136 return static_cast<T>(std::move(*any_cast<remove_cvref_t<T>>(&Value))); 137 } 138 139 template <class T> const T *any_cast(const Any *Value) { 140 using U = remove_cvref_t<T>; 141 assert(Value && any_isa<T>(*Value) && "Bad any cast!"); 142 if (!Value || !any_isa<U>(*Value)) 143 return nullptr; 144 return &static_cast<Any::StorageImpl<U> &>(*Value->Storage).Value; 145 } 146 147 template <class T> T *any_cast(Any *Value) { 148 using U = std::decay_t<T>; 149 assert(Value && any_isa<U>(*Value) && "Bad any cast!"); 150 if (!Value || !any_isa<U>(*Value)) 151 return nullptr; 152 return &static_cast<Any::StorageImpl<U> &>(*Value->Storage).Value; 153 } 154 155 } // end namespace llvm 156 157 #endif // LLVM_ADT_ANY_H 158