[llvm-commits] [llvm] r44430 - /llvm/trunk/include/llvm/ADT/StringMap.h

[Chris Lattner]

Author: lattner
Date: Thu Nov 29 00:04:41 2007
New Revision: 44430

URL: http://llvm.org/viewvc/llvm-project?rev=44430&view=rev
Log:
provide an optional API to allow datatypes in a stringmap to be *gasp* 
initialized with a value if they want, by specializing the 
StringMapEntryInitializer class.

Modified:
    llvm/trunk/include/llvm/ADT/StringMap.h

Modified: llvm/trunk/include/llvm/ADT/StringMap.h
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/ADT/StringMap.h?rev=44430&r1=44429&r2=44430&view=diff

==============================================================================
--- llvm/trunk/include/llvm/ADT/StringMap.h (original)
+++ llvm/trunk/include/llvm/ADT/StringMap.h Thu Nov 29 00:04:41 2007
@@ -23,6 +23,17 @@
   template<typename ValueT>
   class StringMapIterator;
 
+/// StringMapEntryInitializer - This datatype can be partially specialized for
+/// various datatypes in a stringmap to allow them to be initialized when an 
+/// entry is default constructed for the map.
+template<typename ValueTy>
+class StringMapEntryInitializer {
+public:
+  template <typename InitTy>
+  static void Initialize(ValueTy &T, InitTy InitVal) {
+  }
+};
+  
   
 /// StringMapEntryBase - Shared base class of StringMapEntry instances.
 class StringMapEntryBase {
@@ -132,9 +143,10 @@
   
   /// Create - Create a StringMapEntry for the specified key and default
   /// construct the value.
-  template<typename AllocatorTy>
+  template<typename AllocatorTy, typename InitType>
   static StringMapEntry *Create(const char *KeyStart, const char *KeyEnd,
-                                AllocatorTy &Allocator) {
+                                AllocatorTy &Allocator,
+                                InitType InitVal) {
     unsigned KeyLength = KeyEnd-KeyStart;
     
     // Okay, the item doesn't already exist, and 'Bucket' is the bucket to fill
@@ -154,15 +166,30 @@
     char *StrBuffer = const_cast<char*>(NewItem->getKeyData());
     memcpy(StrBuffer, KeyStart, KeyLength);
     StrBuffer[KeyLength] = 0;  // Null terminate for convenience of clients.
+    
+    // Initialize the value if the client wants to.
+    StringMapEntryInitializer<ValueTy>::Initialize(NewItem->getValue(),InitVal);
     return NewItem;
   }
   
+  template<typename AllocatorTy>
+  static StringMapEntry *Create(const char *KeyStart, const char *KeyEnd,
+                                AllocatorTy &Allocator) {
+    return Create(KeyStart, KeyEnd, Allocator, (void*)0);
+  }
+    
+  
   /// Create - Create a StringMapEntry with normal malloc/free.
-  static StringMapEntry *Create(const char *KeyStart, const char *KeyEnd) {
+  template<typename InitType>
+  static StringMapEntry *Create(const char *KeyStart, const char *KeyEnd,
+                                InitType InitVal) {
     MallocAllocator A;
-    return Create(KeyStart, KeyEnd, A);
+    return Create(KeyStart, KeyEnd, A, InitVal);
+  }
+
+  static StringMapEntry *Create(const char *KeyStart, const char *KeyEnd) {
+    return Create(KeyStart, KeyEnd, (void*)0);
   }
-  
   
   /// GetStringMapEntryFromValue - Given a value that is known to be embedded
   /// into a StringMapEntry, return the StringMapEntry itself.
@@ -262,14 +289,16 @@
   /// GetOrCreateValue - Look up the specified key in the table.  If a value
   /// exists, return it.  Otherwise, default construct a value, insert it, and
   /// return.
+  template <typename InitTy>
   StringMapEntry<ValueTy> &GetOrCreateValue(const char *KeyStart, 
-                                            const char *KeyEnd) {
+                                            const char *KeyEnd,
+                                            InitTy Val) {
     unsigned BucketNo = LookupBucketFor(KeyStart, KeyEnd);
     ItemBucket &Bucket = TheTable[BucketNo];
     if (Bucket.Item && Bucket.Item != getTombstoneVal())
       return *static_cast<MapEntryTy*>(Bucket.Item);
     
-    MapEntryTy *NewItem = MapEntryTy::Create(KeyStart, KeyEnd, Allocator);
+    MapEntryTy *NewItem = MapEntryTy::Create(KeyStart, KeyEnd, Allocator, Val);
     
     if (Bucket.Item == getTombstoneVal())
       --NumTombstones;
@@ -284,6 +313,11 @@
     return *NewItem;
   }
   
+  StringMapEntry<ValueTy> &GetOrCreateValue(const char *KeyStart, 
+                                            const char *KeyEnd) {
+    return GetOrCreateValue(KeyStart, KeyEnd, (void*)0);
+  }
+  
   /// 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) {