Make typedefs in ilist public (Visual C++ errors out when they are private).

[oota-llvm.git] / include / llvm / ADT / FoldingSet.h

diff --git a/include/llvm/ADT/FoldingSet.h b/include/llvm/ADT/FoldingSet.h
index d0097613d684ed0ff26f90ebd264bfbb16416efc..f34a62d4f4c6be1076dc3752d13402212105aa36 100644 (file)
--- a/include/llvm/ADT/FoldingSet.h
+++ b/include/llvm/ADT/FoldingSet.h
@@ -22,6 +22,7 @@
 
 namespace llvm {
   class APFloat;
+  class APInt;
 
 /// This folding set used for two purposes:
 ///   1. Given information about a node we want to create, look up the unique
@@ -31,7 +32,7 @@ namespace llvm {
 /// 
 /// This class is implemented as a single-link chained hash table, where the
 /// "buckets" are actually the nodes themselves (the next pointer is in the
-/// node).  The last node points back to the bucket to simplified node removal.
+/// node).  The last node points back to the bucket to simplify node removal.
 ///
 /// Any node that is to be included in the folding set must be a subclass of
 /// FoldingSetNode.  The node class must also define a Profile method used to
@@ -177,6 +178,19 @@ protected:
   virtual void GetNodeProfile(FoldingSetNodeID &ID, Node *N) const = 0;
 };
 
+//===----------------------------------------------------------------------===//
+/// FoldingSetTrait - This trait class is used to define behavior of how
+///  to "profile" (in the FoldingSet parlance) an object of a given type.
+///  The default behavior is to invoke a 'Profile' method on an object, but
+///  through template specialization the behavior can be tailored for specific
+///  types.  Combined with the FoldingSetNodeWrapper classs, one can add objects
+///  to FoldingSets that were not originally designed to have that behavior.
+///
+template<typename T> struct FoldingSetTrait {
+  static inline void Profile(const T& X, FoldingSetNodeID& ID) { X.Profile(ID);}
+  static inline void Profile(T& X, FoldingSetNodeID& ID) { X.Profile(ID); }
+};
+  
 //===--------------------------------------------------------------------===//
 /// FoldingSetNodeID - This class is used to gather all the unique data bits of
 /// a node.  When all the bits are gathered this class is used to produce a
@@ -205,8 +219,11 @@ public:
   void AddInteger(uint64_t I);
   void AddFloat(float F);
   void AddDouble(double D);
-  void AddAPFloat(const APFloat& apf);
   void AddString(const std::string &String);
+  void AddString(const char* String);
+  
+  template <typename T>
+  inline void Add(const T& x) { FoldingSetTrait<T>::Profile(x, *this); }
   
   /// clear - Clear the accumulated profile, allowing this FoldingSetNodeID
   ///  object to be used to compute a new profile.
@@ -225,19 +242,6 @@ public:
 typedef FoldingSetImpl::Node FoldingSetNode;
 template<class T> class FoldingSetIterator;
 template<class T> class FoldingSetBucketIterator;
-
-//===----------------------------------------------------------------------===//
-/// FoldingSetTrait - This trait class is used to define behavior of how
-///  to "profile" (in the FoldingSet parlance) an object of a given type.
-///  The default behavior is to invoke a 'Profile' method on an object, but
-///  through template specialization the behavior can be tailored for specific
-///  types.  Combined with the FoldingSetNodeWrapper classs, one can add objects
-///  to FoldingSets that were not originally designed to have that behavior.
-///
-template<typename T> struct FoldingSetTrait {
-  static inline void Profile(const T& X, FoldingSetNodeID& ID) { X.Profile(ID);}
-  static inline void Profile(T& X, FoldingSetNodeID& ID) { X.Profile(ID); }
-};
   
 //===----------------------------------------------------------------------===//
 /// FoldingSet - This template class is used to instantiate a specialized
@@ -313,7 +317,7 @@ public:
 template<class T>
 class FoldingSetIterator : public FoldingSetIteratorImpl {
 public:
-  FoldingSetIterator(void **Bucket) : FoldingSetIteratorImpl(Bucket) {}
+  explicit FoldingSetIterator(void **Bucket) : FoldingSetIteratorImpl(Bucket) {}
   
   T &operator*() const {
     return *static_cast<T*>(NodePtr);
@@ -341,10 +345,10 @@ class FoldingSetBucketIteratorImpl {
 protected:
   void *Ptr;
 
-  FoldingSetBucketIteratorImpl(void **Bucket);
+  explicit FoldingSetBucketIteratorImpl(void **Bucket);
   
   FoldingSetBucketIteratorImpl(void **Bucket, bool)
-    : Ptr(reinterpret_cast<void*>(Bucket)) {}
+    : Ptr(Bucket) {}
 
   void advance() {
     void *Probe = static_cast<FoldingSetNode*>(Ptr)->getNextInBucket();
@@ -365,7 +369,7 @@ public:
 template<class T>
 class FoldingSetBucketIterator : public FoldingSetBucketIteratorImpl {
 public:
-  FoldingSetBucketIterator(void **Bucket) : 
+  explicit FoldingSetBucketIterator(void **Bucket) : 
     FoldingSetBucketIteratorImpl(Bucket) {}
   
   FoldingSetBucketIterator(void **Bucket, bool) : 
@@ -390,7 +394,7 @@ template <typename T>
 class FoldingSetNodeWrapper : public FoldingSetNode {
   T data;
 public:
-  FoldingSetNodeWrapper(const T& x) : data(x) {}
+  explicit FoldingSetNodeWrapper(const T& x) : data(x) {}
   virtual ~FoldingSetNodeWrapper() {}
   
   template<typename A1>
@@ -423,6 +427,18 @@ public:
 
   operator T&() { return data; }
   operator const T&() const { return data; }
+};  
+  
+//===----------------------------------------------------------------------===//
+// Partial specializations of FoldingSetTrait.
+
+template<typename T> struct FoldingSetTrait<T*> {
+  static inline void Profile(const T* X, FoldingSetNodeID& ID) {
+    ID.AddPointer(X);
+  }
+  static inline void Profile(T* X, FoldingSetNodeID& ID) {
+    ID.AddPointer(X);
+  }
 };
 
 } // End of namespace llvm.