[ADT] Factor out the facade aspect of the iterator_adaptor_base into its

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

diff --git a/include/llvm/ADT/SmallSet.h b/include/llvm/ADT/SmallSet.h
index ef1470501abe92d7090b8c5a2aad2e5a60639ae0..6f36234cb4dd25dd95317aaea2d754ea6a56a569 100644 (file)
--- a/include/llvm/ADT/SmallSet.h
+++ b/include/llvm/ADT/SmallSet.h
@@ -2,8 +2,8 @@
 //
 //                     The LLVM Compiler Infrastructure
 //
-// This file was developed by Chris Lattner and is distributed under
-// the University of Illinois Open Source License. See LICENSE.TXT for details.
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
@@ -14,69 +14,108 @@
 #ifndef LLVM_ADT_SMALLSET_H
 #define LLVM_ADT_SMALLSET_H
 
+#include "llvm/ADT/SmallPtrSet.h"
 #include "llvm/ADT/SmallVector.h"
+#include <set>
 
 namespace llvm {
 
 /// SmallSet - This maintains a set of unique values, optimizing for the case
 /// when the set is small (less than N).  In this case, the set can be
-/// maintained with no mallocs.
+/// maintained with no mallocs.  If the set gets large, we expand to using an
+/// std::set to maintain reasonable lookup times.
 ///
-/// Note that this set does not guarantee that the elements in the set will be
-/// ordered.
-template <typename T, unsigned N>
+/// Note that this set does not provide a way to iterate over members in the
+/// set.
+template <typename T, unsigned N,  typename C = std::less<T> >
 class SmallSet {
+  /// Use a SmallVector to hold the elements here (even though it will never
+  /// reach its 'large' stage) to avoid calling the default ctors of elements
+  /// we will never use.
   SmallVector<T, N> Vector;
+  std::set<T, C> Set;
+  typedef typename SmallVector<T, N>::const_iterator VIterator;
   typedef typename SmallVector<T, N>::iterator mutable_iterator;
 public:
   SmallSet() {}
 
-  // Support iteration.
-  typedef typename SmallVector<T, N>::const_iterator iterator;
-  typedef typename SmallVector<T, N>::const_iterator const_iterator;
-  
-  iterator begin() const { return Vector.begin(); }
-  iterator end() const { return Vector.end(); }
-  
-  bool empty() const { return Vector.empty(); }
-  unsigned size() const { return Vector.size(); }
-  
-  iterator find(const T &V) const {
-    for (iterator I = begin(), E = end(); I != E; ++I)
-      if (*I == V)
-        return I;
-    return end();
+  bool LLVM_ATTRIBUTE_UNUSED_RESULT empty() const {
+    return Vector.empty() && Set.empty();
   }
-  
-  /// count - Return true if the element is in the set.
+
+  unsigned size() const {
+    return isSmall() ? Vector.size() : Set.size();
+  }
+
+  /// count - Return 1 if the element is in the set, 0 otherwise.
   unsigned count(const T &V) const {
-    // Since the collection is small, just do a linear search.
-    return find(V) != end();
+    if (isSmall()) {
+      // Since the collection is small, just do a linear search.
+      return vfind(V) == Vector.end() ? 0 : 1;
+    } else {
+      return Set.count(V);
+    }
   }
-  
+
   /// insert - Insert an element into the set if it isn't already there.
+  /// Returns true if the element is inserted (it was not in the set before).
   bool insert(const T &V) {
-    iterator I = find(V);
-    if (I != end())    // Don't reinsert if it already exists.
+    if (!isSmall())
+      return Set.insert(V).second;
+
+    VIterator I = vfind(V);
+    if (I != Vector.end())    // Don't reinsert if it already exists.
       return false;
-    Vector.push_back(V);
+    if (Vector.size() < N) {
+      Vector.push_back(V);
+      return true;
+    }
+
+    // Otherwise, grow from vector to set.
+    while (!Vector.empty()) {
+      Set.insert(Vector.back());
+      Vector.pop_back();
+    }
+    Set.insert(V);
     return true;
   }
+
+  template <typename IterT>
+  void insert(IterT I, IterT E) {
+    for (; I != E; ++I)
+      insert(*I);
+  }
   
-  void erase(const T &V) {
+  bool erase(const T &V) {
+    if (!isSmall())
+      return Set.erase(V);
     for (mutable_iterator I = Vector.begin(), E = Vector.end(); I != E; ++I)
       if (*I == V) {
         Vector.erase(I);
-        return;
+        return true;
       }
+    return false;
   }
-  
+
   void clear() {
     Vector.clear();
+    Set.clear();
+  }
+private:
+  bool isSmall() const { return Set.empty(); }
+
+  VIterator vfind(const T &V) const {
+    for (VIterator I = Vector.begin(), E = Vector.end(); I != E; ++I)
+      if (*I == V)
+        return I;
+    return Vector.end();
   }
-  
 };
 
+/// If this set is of pointer values, transparently switch over to using
+/// SmallPtrSet for performance.
+template <typename PointeeType, unsigned N>
+class SmallSet<PointeeType*, N> : public SmallPtrSet<PointeeType*, N> {};
 
 } // end namespace llvm