Line data Source code
1 : //===- StringMapEntry.h - String Hash table map interface -------*- 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 defines the StringMapEntry class - it is intended to be a low
11 : /// dependency implementation detail of StringMap that is more suitable for
12 : /// inclusion in public headers than StringMap.h itself is.
13 : ///
14 : //===----------------------------------------------------------------------===//
15 :
16 : #ifndef LLVM_ADT_STRINGMAPENTRY_H
17 : #define LLVM_ADT_STRINGMAPENTRY_H
18 :
19 : #include "llvm/ADT/StringRef.h"
20 : #include <optional>
21 :
22 : namespace llvm {
23 :
24 : /// StringMapEntryBase - Shared base class of StringMapEntry instances.
25 : class StringMapEntryBase {
26 : size_t keyLength;
27 :
28 : public:
29 0 : explicit StringMapEntryBase(size_t keyLength) : keyLength(keyLength) {}
30 :
31 0 : size_t getKeyLength() const { return keyLength; }
32 :
33 : protected:
34 : /// Helper to tail-allocate \p Key. It'd be nice to generalize this so it
35 : /// could be reused elsewhere, maybe even taking an llvm::function_ref to
36 : /// type-erase the allocator and put it in a source file.
37 : template <typename AllocatorTy>
38 : static void *allocateWithKey(size_t EntrySize, size_t EntryAlign,
39 : StringRef Key, AllocatorTy &Allocator);
40 : };
41 :
42 : // Define out-of-line to dissuade inlining.
43 : template <typename AllocatorTy>
44 0 : void *StringMapEntryBase::allocateWithKey(size_t EntrySize, size_t EntryAlign,
45 : StringRef Key,
46 : AllocatorTy &Allocator) {
47 0 : size_t KeyLength = Key.size();
48 :
49 : // Allocate a new item with space for the string at the end and a null
50 : // terminator.
51 0 : size_t AllocSize = EntrySize + KeyLength + 1;
52 0 : void *Allocation = Allocator.Allocate(AllocSize, EntryAlign);
53 0 : assert(Allocation && "Unhandled out-of-memory");
54 :
55 : // Copy the string information.
56 0 : char *Buffer = reinterpret_cast<char *>(Allocation) + EntrySize;
57 0 : if (KeyLength > 0)
58 0 : ::memcpy(Buffer, Key.data(), KeyLength);
59 0 : Buffer[KeyLength] = 0; // Null terminate for convenience of clients.
60 0 : return Allocation;
61 : }
62 :
63 : /// StringMapEntryStorage - Holds the value in a StringMapEntry.
64 : ///
65 : /// Factored out into a separate base class to make it easier to specialize.
66 : /// This is primarily intended to support StringSet, which doesn't need a value
67 : /// stored at all.
68 : template <typename ValueTy>
69 : class StringMapEntryStorage : public StringMapEntryBase {
70 : public:
71 : ValueTy second;
72 :
73 0 : explicit StringMapEntryStorage(size_t keyLength)
74 0 : : StringMapEntryBase(keyLength), second() {}
75 : template <typename... InitTy>
76 0 : StringMapEntryStorage(size_t keyLength, InitTy &&...initVals)
77 : : StringMapEntryBase(keyLength),
78 0 : second(std::forward<InitTy>(initVals)...) {}
79 : StringMapEntryStorage(StringMapEntryStorage &e) = delete;
80 :
81 : const ValueTy &getValue() const { return second; }
82 : ValueTy &getValue() { return second; }
83 :
84 : void setValue(const ValueTy &V) { second = V; }
85 : };
86 :
87 : template <>
88 : class StringMapEntryStorage<std::nullopt_t> : public StringMapEntryBase {
89 : public:
90 0 : explicit StringMapEntryStorage(size_t keyLength,
91 : std::nullopt_t = std::nullopt)
92 0 : : StringMapEntryBase(keyLength) {}
93 : StringMapEntryStorage(StringMapEntryStorage &entry) = delete;
94 :
95 : std::nullopt_t getValue() const { return std::nullopt; }
96 : };
97 :
98 : /// StringMapEntry - This is used to represent one value that is inserted into
99 : /// a StringMap. It contains the Value itself and the key: the string length
100 : /// and data.
101 : template <typename ValueTy>
102 : class StringMapEntry final : public StringMapEntryStorage<ValueTy> {
103 : public:
104 : using StringMapEntryStorage<ValueTy>::StringMapEntryStorage;
105 :
106 : using ValueType = ValueTy;
107 :
108 : StringRef getKey() const {
109 : return StringRef(getKeyData(), this->getKeyLength());
110 : }
111 :
112 : /// getKeyData - Return the start of the string data that is the key for this
113 : /// value. The string data is always stored immediately after the
114 : /// StringMapEntry object.
115 0 : const char *getKeyData() const {
116 0 : return reinterpret_cast<const char *>(this + 1);
117 : }
118 :
119 0 : StringRef first() const {
120 0 : return StringRef(getKeyData(), this->getKeyLength());
121 : }
122 :
123 : /// Create a StringMapEntry for the specified key construct the value using
124 : /// \p InitiVals.
125 : template <typename AllocatorTy, typename... InitTy>
126 0 : static StringMapEntry *create(StringRef key, AllocatorTy &allocator,
127 : InitTy &&...initVals) {
128 0 : return new (StringMapEntryBase::allocateWithKey(
129 : sizeof(StringMapEntry), alignof(StringMapEntry), key, allocator))
130 0 : StringMapEntry(key.size(), std::forward<InitTy>(initVals)...);
131 : }
132 :
133 : /// GetStringMapEntryFromKeyData - Given key data that is known to be embedded
134 : /// into a StringMapEntry, return the StringMapEntry itself.
135 : static StringMapEntry &GetStringMapEntryFromKeyData(const char *keyData) {
136 : char *ptr = const_cast<char *>(keyData) - sizeof(StringMapEntry<ValueTy>);
137 : return *reinterpret_cast<StringMapEntry *>(ptr);
138 : }
139 :
140 : /// Destroy - Destroy this StringMapEntry, releasing memory back to the
141 : /// specified allocator.
142 0 : template <typename AllocatorTy> void Destroy(AllocatorTy &allocator) {
143 : // Free memory referenced by the item.
144 0 : size_t AllocSize = sizeof(StringMapEntry) + this->getKeyLength() + 1;
145 0 : this->~StringMapEntry();
146 0 : allocator.Deallocate(static_cast<void *>(this), AllocSize,
147 : alignof(StringMapEntry));
148 0 : }
149 : };
150 :
151 : // Allow structured bindings on StringMapEntry.
152 : template <std::size_t Index, typename ValueTy>
153 : decltype(auto) get(const StringMapEntry<ValueTy> &E) {
154 : static_assert(Index < 2);
155 : if constexpr (Index == 0)
156 : return E.first();
157 : else
158 : return E.second;
159 : }
160 :
161 : } // end namespace llvm
162 :
163 : namespace std {
164 : template <typename ValueTy>
165 : struct tuple_size<llvm::StringMapEntry<ValueTy>>
166 : : std::integral_constant<std::size_t, 2> {};
167 :
168 : template <std::size_t I, typename ValueTy>
169 : struct tuple_element<I, llvm::StringMapEntry<ValueTy>>
170 : : std::conditional<I == 0, llvm::StringRef, ValueTy> {};
171 : } // namespace std
172 :
173 : #endif // LLVM_ADT_STRINGMAPENTRY_H
|
