Created
September 27, 2010 20:36
-
-
Save brycelelbach/599780 to your computer and use it in GitHub Desktop.
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
//===- llvm/ADT/scoped_ptr.h - basic smart pointer --------------*- C++ -*-===// | |
// | |
// The LLVM Compiler Infrastructure | |
// | |
// This file is distributed under the University of Illinois Open Source | |
// License. See LICENSE.TXT for details. | |
// | |
//===----------------------------------------------------------------------===// | |
// | |
// This file defines the scoped_ptr smart pointer: 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. | |
// | |
//===----------------------------------------------------------------------===// | |
// | |
// (C) Copyright Greg Colvin and Beman Dawes 1998, 1999. | |
// Copyright (c) 2001, 2002 Peter Dimov | |
// | |
// Distributed under the Boost Software License, Version 1.0. (See | |
// accompanying file llvm/docs/BOOST_LICENSE_1_0.txt or copy at | |
// http://www.boost.org/LICENSE_1_0.txt ) | |
// | |
// http://www.boost.org/libs/smart_ptr/scoped_ptr.htm | |
// | |
#ifndef LLVM_SCOPED_PTR_HPP_INCLUDED | |
#define LLVM_SCOPED_PTR_HPP_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; | |
} | |
// 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; | |
public: | |
typedef T element_type; | |
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; | |
} | |
}; | |
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(); | |
} | |
} // namespace llvm | |
#endif // #ifndef LLVM_SCOPED_PTR_HPP_INCLUDED |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment