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::size_type size_type;
39 typedef typename VectorType::iterator
iterator;
44 size_type
size()
const {
return Vector.size(); }
57 return Vector.empty();
60 std::pair<KeyT, ValueT> &
front() {
return Vector.front(); }
61 const std::pair<KeyT, ValueT> &
front()
const {
return Vector.front(); }
62 std::pair<KeyT, ValueT> &
back() {
return Vector.back(); }
63 const std::pair<KeyT, ValueT> &
back()
const {
return Vector.back(); }
76 std::pair<KeyT, unsigned> Pair = std::make_pair(Key, 0);
77 std::pair<typename MapType::iterator, bool> Result = Map.insert(Pair);
78 unsigned &
I = Result.first->second;
80 Vector.push_back(std::make_pair(Key, ValueT()));
81 I = Vector.size() - 1;
83 return Vector[
I].second;
86 ValueT
lookup(
const KeyT &Key)
const {
87 typename MapType::const_iterator Pos = Map.find(Key);
88 return Pos == Map.end()? ValueT() : Vector[Pos->second].second;
91 std::pair<iterator, bool>
insert(
const std::pair<KeyT, ValueT> &KV) {
92 std::pair<KeyT, unsigned> Pair = std::make_pair(KV.first, 0);
93 std::pair<typename MapType::iterator, bool> Result = Map.insert(Pair);
94 unsigned &
I = Result.first->second;
96 Vector.push_back(std::make_pair(KV.first, KV.second));
97 I = Vector.size() - 1;
98 return std::make_pair(std::prev(
end()),
true);
100 return std::make_pair(
begin() + I,
false);
103 size_type
count(
const KeyT &Key)
const {
104 typename MapType::const_iterator Pos = Map.find(Key);
105 return Pos == Map.end()? 0 : 1;
109 typename MapType::const_iterator Pos = Map.find(Key);
110 return Pos == Map.end()? Vector.end() :
111 (Vector.begin() + Pos->second);
115 typename MapType::const_iterator Pos = Map.find(Key);
116 return Pos == Map.end()? Vector.end() :
117 (Vector.begin() + Pos->second);
122 typename MapType::iterator Pos = Map.find(Vector.back().first);
134 typename VectorType::iterator
erase(
typename VectorType::iterator Iterator) {
135 Map.erase(Iterator->first);
136 auto Next = Vector.erase(Iterator);
137 if (Next == Vector.end())
141 size_t Index = Next - Vector.begin();
142 for (
auto &
I : Map) {
143 assert(
I.second != Index &&
"Index was already erased!");
144 if (
I.second > Index)
154 auto Iterator =
find(Key);
155 if (Iterator ==
end())
168 template <
typename KeyT,
typename ValueT,
typename MapType,
typename VectorType>
169 template <
class Function>
171 auto O = Vector.begin();
172 for (
auto I = O, E = Vector.end();
I != E; ++
I) {
182 Map[O->first] = O - Vector.begin();
187 Vector.erase(O, Vector.end());
192 template <
typename KeyT,
typename ValueT,
unsigned N>
194 :
MapVector<KeyT, ValueT, SmallDenseMap<KeyT, unsigned, N>,
195 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)
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::const_iterator const_iterator
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.
VectorType - 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.
void swap(MapVector &RHS)