llvm/ADT/DenseMap.h

40 struct DenseMapPair : public std::pair<KeyT, ValueT> {
41   using std::pair<KeyT, ValueT>::pair;
43   KeyT &getFirst() { return std::pair<KeyT, ValueT>::first; }
44   const KeyT &getFirst() const { return std::pair<KeyT, ValueT>::first; }
45   ValueT &getSecond() { return std::pair<KeyT, ValueT>::second; }
46   const ValueT &getSecond() const { return std::pair<KeyT, ValueT>::second; }
195   std::pair<iterator, bool> insert(const std::pair<KeyT, ValueT> &KV) {
202   std::pair<iterator, bool> insert(std::pair<KeyT, ValueT> &&KV) {
203     return try_emplace(std::move(KV.first), std::move(KV.second));
210   std::pair<iterator, bool> try_emplace(KeyT &&Key, Ts &&... Args) {
213       return std::make_pair(
219         InsertIntoBucket(TheBucket, std::move(Key), std::forward<Ts>(Args)...);
220     return std::make_pair(
229   std::pair<iterator, bool> try_emplace(const KeyT &Key, Ts &&... Args) {
232       return std::make_pair(
237     TheBucket = InsertIntoBucket(TheBucket, Key, std::forward<Ts>(Args)...);
238     return std::make_pair(
249   std::pair<iterator, bool> insert_as(std::pair<KeyT, ValueT> &&KV,
253       return std::make_pair(
258     TheBucket = InsertIntoBucketWithLookup(TheBucket, std::move(KV.first),
259                                            std::move(KV.second), Val);
260     return std::make_pair(
308     return *InsertIntoBucket(TheBucket, std::move(Key));
312     return FindAndConstruct(std::move(Key)).second;
379         DestBucket->getFirst() = std::move(B->getFirst());
380         ::new (&DestBucket->getSecond()) ValueT(std::move(B->getSecond()));
424     static_assert(std::is_base_of<DenseMapBase, DerivedT>::value,
519     TheBucket->getFirst() = std::forward<KeyArg>(Key);
520     ::new (&TheBucket->getSecond()) ValueT(std::forward<ValueArgs>(Values)...);
529     TheBucket->getFirst() = std::move(Key);
530     ::new (&TheBucket->getSecond()) ValueT(std::move(Value));
714     init(std::distance(I, E));
718   DenseMap(std::initializer_list<typename BaseT::value_type> Vals) {
731     std::swap(Buckets, RHS.Buckets);
732     std::swap(NumEntries, RHS.NumEntries);
733     std::swap(NumTombstones, RHS.NumTombstones);
734     std::swap(NumBuckets, RHS.NumBuckets);
776     allocateBuckets(std::max<unsigned>(64, static_cast<unsigned>(NextPowerOf2(AtLeast-1))));
798       NewNumBuckets = std::max(64, 1 << (Log2_32_Ceil(OldNumEntries) + 1));
893     init(NextPowerOf2(std::distance(I, E)));
906     std::swap(NumTombstones, RHS.NumTombstones);
924           std::swap(*LHSB, *RHSB);
928         std::swap(LHSB->getFirst(), RHSB->getFirst());
930           ::new (&RHSB->getSecond()) ValueT(std::move(LHSB->getSecond()));
933           ::new (&LHSB->getSecond()) ValueT(std::move(RHSB->getSecond()));
940       std::swap(getLargeRep()->Buckets, RHS.getLargeRep()->Buckets);
941       std::swap(getLargeRep()->NumBuckets, RHS.getLargeRep()->NumBuckets);
949     LargeRep TmpRep = std::move(*LargeSide.getLargeRep());
959       ::new (&NewB->getFirst()) KeyT(std::move(OldB->getFirst()));
963         ::new (&NewB->getSecond()) ValueT(std::move(OldB->getSecond()));
971     new (SmallSide.getLargeRep()) LargeRep(std::move(TmpRep));
1010       AtLeast = std::max<unsigned>(64, NextPowerOf2(AtLeast-1));
1027           ::new (&TmpEnd->getFirst()) KeyT(std::move(P->getFirst()));
1028           ::new (&TmpEnd->getSecond()) ValueT(std::move(P->getSecond()));
1046     LargeRep OldRep = std::move(*getLargeRep());
1168       typename std::conditional<IsConst, const Bucket, Bucket>::type;
1171   using iterator_category = std::forward_iterator_tag;
1197             typename = typename std::enable_if<!IsConstSrc && IsConst>::type>