Author: lattner
Date: Mon Dec 17 12:58:23 2007
New Revision: 45112
URL: http://llvm.org/viewvc/llvm-project?rev=45112&view=rev
Log:
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.
Modified:
llvm/trunk/include/llvm/ADT/scoped_ptr.h
Modified: llvm/trunk/include/llvm/ADT/scoped_ptr.h
URL:
http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/ADT/scoped_ptr.h?rev=45112&r1=45111&r2=45112&view=diff
==============================================================================
--- llvm/trunk/include/llvm/ADT/scoped_ptr.h (original)
+++ llvm/trunk/include/llvm/ADT/scoped_ptr.h Mon Dec 17 12:58:23 2007
@@ -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);
- }
-
- 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);
- }
-
- T & operator*() const // never throws
- {
- assert(ptr != 0 && "scoped_ptr: Trying to dereference a null
pointeur");
- return *ptr;
- }
-
- T * operator->() const // never throws
- {
- assert(ptr != 0 && "scoped_ptr: Trying to dereference a null
pointeur");
- return ptr;
- }
-
- T * get() const // never throws
- {
- return ptr;
- }
-
- // 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;
- }
-
- bool operator! () const // never throws
- {
- return ptr == 0;
- }
-
- void swap(scoped_ptr & b) // never throws
- {
- T * tmp = b.ptr;
- b.ptr = ptr;
- ptr = tmp;
- }
+ ~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;
+ }
+
+ /// 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 {
+ assert(ptr != 0 && "scoped_ptr: Trying to dereference a null pointer");
+ return ptr;
+ }
+
+ T* get() const {
+ return ptr;
+ }
+
+ // 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;
+ }
+
+ bool operator!() const { // never throws
+ return ptr == 0;
+ }
+
+ 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
_______________________________________________
llvm-commits mailing list
llvm-commits@cs.uiuc.edu
http://lists.cs.uiuc.edu/mailman/listinfo/llvm-commits
