[llvm-commits] CVS: llvm/include/llvm/ADT/StringMap.h

[Chris Lattner]

Changes in directory llvm/include/llvm/ADT:

StringMap.h updated: 1.9 -> 1.10
---
Log message:

Add support for removing elements out of StringMap.


---
Diffs of the changes:  (+42 -1)

 StringMap.h |   43 ++++++++++++++++++++++++++++++++++++++++++-
 1 files changed, 42 insertions(+), 1 deletion(-)


Index: llvm/include/llvm/ADT/StringMap.h
diff -u llvm/include/llvm/ADT/StringMap.h:1.9 llvm/include/llvm/ADT/StringMap.h:1.10
--- llvm/include/llvm/ADT/StringMap.h:1.9	Sun Feb 11 13:49:41 2007
+++ llvm/include/llvm/ADT/StringMap.h	Sun Feb 11 14:58:00 2007
@@ -52,6 +52,7 @@
   ItemBucket *TheTable;
   unsigned NumBuckets;
   unsigned NumItems;
+  unsigned NumTombstones;
   unsigned ItemSize;
 protected:
   StringMapImpl(unsigned InitSize, unsigned ItemSize);
@@ -68,6 +69,14 @@
   /// in the map, return the bucket number of the key.  Otherwise return -1.
   /// This does not modify the map.
   int FindKey(const char *KeyStart, const char *KeyEnd) const;
+
+  /// RemoveKey - Remove the specified StringMapEntry from the table, but do not
+  /// delete it.  This aborts if the value isn't in the table.
+  void RemoveKey(StringMapEntryBase *V);
+
+  /// RemoveKey - Remove the StringMapEntry for the specified key from the
+  /// table, returning it.  If the key is not in the table, this returns null.
+  StringMapEntryBase *RemoveKey(const char *KeyStart, const char *KeyEnd);
   
 public:
   static StringMapEntryBase *getTombstoneVal() {
@@ -193,6 +202,28 @@
     return const_iterator(TheTable+Bucket);
   }
   
+  /// insert - Insert the specified key/value pair into the map.  If the key
+  /// already exists in the map, return false and ignore the request, otherwise
+  /// insert it and return true.
+  bool insert(MapEntryTy *KeyValue) {
+    unsigned BucketNo =
+      LookupBucketFor(KeyValue->getKeyData(),
+                      KeyValue->getKeyData()+KeyValue->getKeyLength());
+    ItemBucket &Bucket = TheTable[BucketNo];
+    if (Bucket.Item && Bucket.Item != getTombstoneVal()) 
+      return false;  // Already exists in map.
+    
+    if (Bucket.Item == getTombstoneVal())
+      --NumTombstones;
+    Bucket.Item = KeyValue;
+    ++NumItems;
+    
+    // If the hash table is now more than 3/4 full, rehash into a larger table.
+    if (NumItems > NumBuckets*3/4)
+      RehashTable();
+    return true;
+  }
+  
   /// GetOrCreateValue - Look up the specified key in the table.  If a value
   /// exists, return it.  Otherwise, default construct a value, insert it, and
   /// return.
@@ -200,10 +231,13 @@
                                             const char *KeyEnd) {
     unsigned BucketNo = LookupBucketFor(KeyStart, KeyEnd);
     ItemBucket &Bucket = TheTable[BucketNo];
-    if (Bucket.Item)
+    if (Bucket.Item && Bucket.Item != getTombstoneVal())
       return *static_cast<MapEntryTy*>(Bucket.Item);
     
     MapEntryTy *NewItem = MapEntryTy::Create(KeyStart, KeyEnd, Allocator);
+    
+    if (Bucket.Item == getTombstoneVal())
+      --NumTombstones;
     ++NumItems;
     
     // Fill in the bucket for the hash table.  The FullHashValue was already
@@ -216,6 +250,12 @@
     return *NewItem;
   }
   
+  /// remove - Remove the specified key/value pair from the map, but do not
+  /// erase it.  This aborts if the key is not in the map.
+  void remove(MapEntryTy *KeyValue) {
+    RemoveKey(KeyValue);
+  }
+  
   ~StringMap() {
     for (ItemBucket *I = TheTable, *E = TheTable+NumBuckets; I != E; ++I) {
       if (MapEntryTy *Id = static_cast<MapEntryTy*>(I->Item))
@@ -228,6 +268,7 @@
 
 template<typename ValueTy>
 class StringMapConstIterator {
+protected:
   StringMapImpl::ItemBucket *Ptr;
 public:
   StringMapConstIterator(StringMapImpl::ItemBucket *Bucket) : Ptr(Bucket) {