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 | // We also cannot mark it as `const`, otherwise msvc merges all definitions |
35 | // when lto is enabled, making any comparison return true. |
36 | template <typename T> struct TypeId { static char Id; }; |
37 | |
38 | struct StorageBase { |
39 | virtual ~StorageBase() = default; |
40 | virtual std::unique_ptr<StorageBase> clone() const = 0; |
41 | virtual const void *id() const = 0; |
42 | }; |
43 | |
44 | template <typename T> struct StorageImpl : public StorageBase { |
45 | explicit StorageImpl(const T &Value) : Value(Value) {} |
46 | |
47 | explicit StorageImpl(T &&Value) : Value(std::move(Value)) {} |
48 | |
49 | std::unique_ptr<StorageBase> clone() const override { |
50 | return std::make_unique<StorageImpl<T>>(Value); |
51 | } |
52 | |
53 | const void *id() const override { return &TypeId<T>::Id; } |
54 | |
55 | T Value; |
56 | |
57 | private: |
58 | StorageImpl &operator=(const StorageImpl &Other) = delete; |
59 | StorageImpl(const StorageImpl &Other) = delete; |
60 | }; |
61 | |
62 | public: |
63 | Any() = default; |
64 | |
65 | Any(const Any &Other) |
66 | : Storage(Other.Storage ? Other.Storage->clone() : nullptr) {} |
67 | |
68 | // When T is Any or T is not copy-constructible we need to explicitly disable |
69 | // the forwarding constructor so that the copy constructor gets selected |
70 | // instead. |
71 | template <typename T, |
72 | std::enable_if_t< |
73 | std::conjunction< |
74 | std::negation<std::is_same<std::decay_t<T>, Any>>, |
75 | // We also disable this overload when an `Any` object can be |
76 | // converted to the parameter type because in that case, |
77 | // this constructor may combine with that conversion during |
78 | // overload resolution for determining copy |
79 | // constructibility, and then when we try to determine copy |
80 | // constructibility below we may infinitely recurse. This is |
81 | // being evaluated by the standards committee as a potential |
82 | // DR in `std::any` as well, but we're going ahead and |
83 | // adopting it to work-around usage of `Any` with types that |
84 | // need to be implicitly convertible from an `Any`. |
85 | std::negation<std::is_convertible<Any, std::decay_t<T>>>, |
86 | std::is_copy_constructible<std::decay_t<T>>>::value, |
87 | int> = 0> |
88 | Any(T &&Value) { |
89 | Storage = |
90 | std::make_unique<StorageImpl<std::decay_t<T>>>(std::forward<T>(Value)); |
91 | } |
92 | |
93 | Any(Any &&Other) : Storage(std::move(Other.Storage)) {} |
94 | |
95 | Any &swap(Any &Other) { |
96 | std::swap(x&: Storage, y&: Other.Storage); |
97 | return *this; |
98 | } |
99 | |
100 | Any &operator=(Any Other) { |
101 | Storage = std::move(Other.Storage); |
102 | return *this; |
103 | } |
104 | |
105 | bool has_value() const { return !!Storage; } |
106 | |
107 | void reset() { Storage.reset(); } |
108 | |
109 | private: |
110 | // Only used for the internal llvm::Any implementation |
111 | template <typename T> bool isa() const { |
112 | if (!Storage) |
113 | return false; |
114 | return Storage->id() == &Any::TypeId<remove_cvref_t<T>>::Id; |
115 | } |
116 | |
117 | template <class T> friend T any_cast(const Any &Value); |
118 | template <class T> friend T any_cast(Any &Value); |
119 | template <class T> friend T any_cast(Any &&Value); |
120 | template <class T> friend const T *any_cast(const Any *Value); |
121 | template <class T> friend T *any_cast(Any *Value); |
122 | template <typename T> friend bool any_isa(const Any &Value); |
123 | |
124 | std::unique_ptr<StorageBase> Storage; |
125 | }; |
126 | |
127 | // Define the type id and initialize with a non-zero value. |
128 | // Initializing with a zero value means the variable can end up in either the |
129 | // .data or the .bss section. This can lead to multiple definition linker errors |
130 | // when some object files are compiled with a compiler that puts the variable |
131 | // into .data but they are linked to object files from a different compiler that |
132 | // put the variable into .bss. To prevent this issue from happening, initialize |
133 | // the variable with a non-zero value, which forces it to land in .data (because |
134 | // .bss is zero-initialized). |
135 | // See also https://github.com/llvm/llvm-project/issues/62270 |
136 | template <typename T> char Any::TypeId<T>::Id = 1; |
137 | |
138 | template <class T> T any_cast(const Any &Value) { |
139 | assert(Value.isa<T>() && "Bad any cast!" ); |
140 | return static_cast<T>(*any_cast<remove_cvref_t<T>>(&Value)); |
141 | } |
142 | |
143 | template <class T> T any_cast(Any &Value) { |
144 | assert(Value.isa<T>() && "Bad any cast!" ); |
145 | return static_cast<T>(*any_cast<remove_cvref_t<T>>(&Value)); |
146 | } |
147 | |
148 | template <class T> T any_cast(Any &&Value) { |
149 | assert(Value.isa<T>() && "Bad any cast!" ); |
150 | return static_cast<T>(std::move(*any_cast<remove_cvref_t<T>>(&Value))); |
151 | } |
152 | |
153 | template <class T> const T *any_cast(const Any *Value) { |
154 | using U = remove_cvref_t<T>; |
155 | if (!Value || !Value->isa<U>()) |
156 | return nullptr; |
157 | return &static_cast<Any::StorageImpl<U> &>(*Value->Storage).Value; |
158 | } |
159 | |
160 | template <class T> T *any_cast(Any *Value) { |
161 | using U = std::decay_t<T>; |
162 | if (!Value || !Value->isa<U>()) |
163 | return nullptr; |
164 | return &static_cast<Any::StorageImpl<U> &>(*Value->Storage).Value; |
165 | } |
166 | |
167 | } // end namespace llvm |
168 | |
169 | #endif // LLVM_ADT_ANY_H |
170 | |