17 #ifndef LLVM_ADT_MAPVECTOR_H
18 #define LLVM_ADT_MAPVECTOR_H
29 template<
typename KeyT,
typename ValueT,
31 typename VectorType = std::vector<std::pair<KeyT, ValueT> > >
33 typedef typename VectorType::value_type value_type;
34 typedef typename VectorType::size_type size_type;
40 typedef typename VectorType::iterator
iterator;
48 return std::move(Vector);
51 size_type
size()
const {
return Vector.size(); }
64 return Vector.empty();
67 std::pair<KeyT, ValueT> &
front() {
return Vector.front(); }
68 const std::pair<KeyT, ValueT> &
front()
const {
return Vector.front(); }
69 std::pair<KeyT, ValueT> &
back() {
return Vector.back(); }
70 const std::pair<KeyT, ValueT> &
back()
const {
return Vector.back(); }
83 std::pair<KeyT, unsigned> Pair = std::make_pair(Key, 0);
84 std::pair<typename MapType::iterator, bool> Result = Map.insert(Pair);
85 unsigned &
I = Result.first->second;
87 Vector.push_back(std::make_pair(Key,
ValueT()));
88 I = Vector.size() - 1;
90 return Vector[
I].second;
95 static_assert(std::is_copy_constructible<ValueT>::value,
96 "Cannot call lookup() if ValueT is not copyable.");
97 typename MapType::const_iterator Pos = Map.find(Key);
98 return Pos == Map.end()?
ValueT() : Vector[Pos->second].second;
101 std::pair<iterator, bool>
insert(
const std::pair<KeyT, ValueT> &KV) {
102 std::pair<KeyT, unsigned> Pair = std::make_pair(KV.first, 0);
103 std::pair<typename MapType::iterator, bool> Result = Map.insert(Pair);
104 unsigned &
I = Result.first->second;
106 Vector.push_back(std::make_pair(KV.first, KV.second));
107 I = Vector.size() - 1;
108 return std::make_pair(std::prev(
end()),
true);
110 return std::make_pair(
begin() + I,
false);
113 std::pair<iterator, bool>
insert(std::pair<KeyT, ValueT> &&KV) {
115 std::pair<KeyT, unsigned> Pair = std::make_pair(KV.first, 0);
116 std::pair<typename MapType::iterator, bool> Result = Map.insert(Pair);
117 unsigned &
I = Result.first->second;
119 Vector.push_back(std::move(KV));
120 I = Vector.size() - 1;
121 return std::make_pair(std::prev(
end()),
true);
123 return std::make_pair(
begin() + I,
false);
126 size_type
count(
const KeyT &Key)
const {
127 typename MapType::const_iterator Pos = Map.find(Key);
128 return Pos == Map.end()? 0 : 1;
132 typename MapType::const_iterator Pos = Map.find(Key);
133 return Pos == Map.end()? Vector.end() :
134 (Vector.begin() + Pos->second);
138 typename MapType::const_iterator Pos = Map.find(Key);
139 return Pos == Map.end()? Vector.end() :
140 (Vector.begin() + Pos->second);
145 typename MapType::iterator Pos = Map.find(Vector.back().first);
157 typename VectorType::iterator
erase(
typename VectorType::iterator Iterator) {
158 Map.erase(Iterator->first);
159 auto Next = Vector.erase(Iterator);
160 if (Next == Vector.end())
164 size_t Index = Next - Vector.begin();
165 for (
auto &
I : Map) {
166 assert(
I.second != Index &&
"Index was already erased!");
167 if (
I.second > Index)
177 auto Iterator =
find(Key);
178 if (Iterator ==
end())
191 template <
typename KeyT,
typename ValueT,
typename MapType,
typename VectorType>
192 template <
class Function>
194 auto O = Vector.begin();
195 for (
auto I = O,
E = Vector.end();
I !=
E; ++
I) {
205 Map[O->first] = O - Vector.begin();
210 Vector.erase(O, Vector.end());
215 template <
typename KeyT,
typename ValueT,
unsigned N>
217 :
MapVector<KeyT, ValueT, SmallDenseMap<KeyT, unsigned, N>,
218 SmallVector<std::pair<KeyT, ValueT>, N>> {
const_iterator begin() const
VectorType::iterator iterator
const std::pair< KeyT, ValueT > & back() const
void pop_back()
Remove the last element from the vector.
const_iterator end() const
This class implements a map that also provides access to all stored values in a deterministic order...
VectorType::iterator erase(typename VectorType::iterator Iterator)
Remove the element given by Iterator.
std::pair< KeyT, ValueT > & back()
A MapVector that performs no allocations if smaller than a certain size.
ValueT & operator[](const KeyT &Key)
VectorType::const_reverse_iterator const_reverse_iterator
const_iterator find(const KeyT &Key) const
VectorType::reverse_iterator reverse_iterator
iterator find(const KeyT &Key)
static GCRegistry::Add< CoreCLRGC > E("coreclr","CoreCLR-compatible GC")
void remove_if(Predicate Pred)
Remove the elements that match the predicate.
ValueT lookup(const KeyT &Key) const
const_reverse_iterator rend() const
const std::pair< KeyT, ValueT > & front() const
const_reverse_iterator rbegin() const
VectorType takeVector()
Clear the MapVector and return the underlying vector.
VectorType::const_iterator const_iterator
std::pair< iterator, bool > insert(std::pair< KeyT, ValueT > &&KV)
std::pair< iterator, bool > insert(const std::pair< KeyT, ValueT > &KV)
reverse_iterator rbegin()
void swap(llvm::BitVector &LHS, llvm::BitVector &RHS)
Implement std::swap in terms of BitVector swap.
Class to represent vector types.
size_type count(const KeyT &Key) const
std::pair< KeyT, ValueT > & front()
size_type erase(const KeyT &Key)
Remove all elements with the key value Key.
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
void swap(MapVector &RHS)