cleanup this code, making it more "llvm-like".

Add comments to reset indicating that it deletes its pointer.
Add a new take() method, which can be used to get the pointer
without it being deleted.


git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@45112 91177308-0d34-0410-b5e6-96231b3b80d8

include/llvm/ADT/scoped_ptr.h

@@ -23,105 +23,100 @@
 //
 //  http://www.boost.org/libs/smart_ptr/scoped_ptr.htm
 //
-
-#ifndef LLVM_SCOPED_PTR_HPP_INCLUDED
-#define LLVM_SCOPED_PTR_HPP_INCLUDED
+#ifndef LLVM_SCOPED_PTR_H_INCLUDED
+#define LLVM_SCOPED_PTR_H_INCLUDED
 
 #include <cassert>
 
 namespace llvm {
 
 // verify that types are complete for increased safety
-template<class T> inline void checked_delete(T * x) {
-    // intentionally complex - simplification causes regressions
-    typedef char type_must_be_complete[ sizeof(T)? 1: -1 ];
-    (void) sizeof(type_must_be_complete);
-    delete x;
+template<class T>
+inline void checked_delete(T * x) {
+  // intentionally complex - simplification causes warnings in some compilers.
+  typedef char type_must_be_complete[sizeof(T) ? 1 : -1];
+  (void)sizeof(type_must_be_complete);
+  delete x;
 }
 
-//  scoped_ptr mimics a built-in pointer except that it guarantees deletion
-//  of the object pointed to, either on destruction of the scoped_ptr or via
-//  an explicit reset(). scoped_ptr is a simple solution for simple needs;
-//  use shared_ptr or std::auto_ptr if your needs are more complex.
-
-template<class T> class scoped_ptr // noncopyable
-{
-private:
-
-    T * ptr;
-
-    scoped_ptr(scoped_ptr const &);
-    scoped_ptr & operator=(scoped_ptr const &);
-
-    typedef scoped_ptr<T> this_type;
-
+/// scoped_ptr mimics a built-in pointer except that it guarantees deletion
+/// of the object pointed to, either on destruction of the scoped_ptr or via
+/// an explicit reset(). scoped_ptr is a simple solution for simple needs;
+/// use shared_ptr or std::auto_ptr if your needs are more complex.
+template<class T> 
+class scoped_ptr {// noncopyable
+  T *ptr;
+  scoped_ptr(scoped_ptr const &);             // DO NOT IMPLEMENT
+  scoped_ptr & operator=(scoped_ptr const &); // DO NOT IMPLEMENT
+  typedef scoped_ptr<T> this_type;
 public:
+  typedef T element_type;
 
-    typedef T element_type;
+  explicit scoped_ptr(T * p = 0): ptr(p) {} // never throws
 
-    explicit scoped_ptr(T * p = 0): ptr(p) // never throws
-    {
-    }
+  ~scoped_ptr() { // never throws
+    llvm::checked_delete(ptr);
+  }
 
-    ~scoped_ptr() // never throws
-    {
-       llvm::checked_delete(ptr);
-    }
+  /// reset - Change the current pointee to the specified pointer.  Note that
+  /// calling this with any pointer (including a null pointer) deletes the
+  /// current pointer.
+  void reset(T *p = 0) { 
+    // catch self-reset errors
+    assert((p == 0 || p != ptr) && "scoped_ptr: self-reset error");
+    T *tmp = ptr;
+    ptr = p;
+    delete tmp;
+  }
 
-    void reset(T * p = 0) // never throws
-    {
-        assert( (p == 0 || p != ptr) && "scoped_ptr: self-reset error"); // catch self-reset errors
-        this_type(p).swap(*this);
-    }
+  /// take - Reset the scoped pointer to null and return its pointer.  This does
+  /// not delete the pointer before returning it.
+  T *take() { 
+    T *P = ptr;
+    ptr = 0;
+    return P;
+  }
+  
+  T& operator*() const {
+    assert(ptr != 0 && "scoped_ptr: Trying to dereference a null pointer");
+    return *ptr;
+  }
 
-    T & operator*() const // never throws
-    {
-        assert(ptr != 0 && "scoped_ptr: Trying to dereference a null pointeur");
-        return *ptr;
-    }
+  T* operator->() const {
+    assert(ptr != 0 && "scoped_ptr: Trying to dereference a null pointer");
+    return ptr;
+  }
 
-    T * operator->() const // never throws
-    {
-        assert(ptr != 0 && "scoped_ptr: Trying to dereference a null pointeur");
-        return ptr;
-    }
+  T* get() const {
+    return ptr;
+  }
 
-    T * get() const // never throws
-    {
-        return ptr;
-    }
+  // implicit conversion to "bool"
+  typedef T * this_type::*unspecified_bool_type;
 
-    // implicit conversion to "bool"
-    typedef T * this_type::*unspecified_bool_type;
+  operator unspecified_bool_type() const {// never throws
+    return ptr == 0? 0: &this_type::ptr;
+  }
 
-    operator unspecified_bool_type() const // never throws
-    {
-        return ptr == 0? 0: &this_type::ptr;
-    }
+  bool operator!() const { // never throws
+    return ptr == 0;
+  }
 
-    bool operator! () const // never throws
-    {
-        return ptr == 0;
-    }
-
-    void swap(scoped_ptr & b) // never throws
-    {
-        T * tmp = b.ptr;
-        b.ptr = ptr;
-        ptr = tmp;
-    }
+  void swap(scoped_ptr &b) {// never throws
+    T * tmp = b.ptr;
+    b.ptr = ptr;
+    ptr = tmp;
+  }
 };
 
-template<class T> inline void swap(scoped_ptr<T> & a, scoped_ptr<T> & b) // never throws
-{
-    a.swap(b);
+template<class T> inline void swap(scoped_ptr<T> &a, scoped_ptr<T> &b) {
+  // never throws
+  a.swap(b);
 }
 
 // get_pointer(p) is a generic way to say p.get()
-
-template<class T> inline T * get_pointer(scoped_ptr<T> const & p)
-{
-    return p.get();
+template<class T> inline T * get_pointer(scoped_ptr<T> const &p) {
+  return p.get();
 }
 
 } // namespace llvm