diff options
Diffstat (limited to 'intern/memutil/MEM_SmartPtr.h')
| -rw-r--r-- | intern/memutil/MEM_SmartPtr.h | 245 |
1 files changed, 0 insertions, 245 deletions
diff --git a/intern/memutil/MEM_SmartPtr.h b/intern/memutil/MEM_SmartPtr.h deleted file mode 100644 index e0d7b81290f..00000000000 --- a/intern/memutil/MEM_SmartPtr.h +++ /dev/null @@ -1,245 +0,0 @@ -/* - * ***** BEGIN GPL LICENSE BLOCK ***** - * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the GNU General Public License - * as published by the Free Software Foundation; either version 2 - * of the License, or (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program; if not, write to the Free Software Foundation, - * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. - * - * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV. - * All rights reserved. - * - * The Original Code is: all of this file. - * - * Contributor(s): none yet. - * - * ***** END GPL LICENSE BLOCK ***** - */ - -/** \file memutil/MEM_SmartPtr.h - * \ingroup memutil - */ - -/** - * @file MEM_SmartPtr.h - * Declaration of MEM_RefCounted and MEM_RefCountable classes. - * @author Laurence - */ - -#ifndef __MEM_SMARTPTR_H__ -#define __MEM_SMARTPTR_H__ - - -#include <stdlib.h> // for NULL ! - - -/** - * \section MEM_SmartPtr - * This class defines a smart pointer similar to that defined in - * the Standard Template Library but without the painful get() - * semantics to access the internal c style pointer. - * - * It is often useful to explicitly declare ownership of memory - * allocated on the heap within class or function scope. This - * class helps you to encapsulate this ownership within a value - * type. When an instance of this class goes out of scope it - * makes sure that any memory associated with it's internal pointer - * is deleted. It can help to inform users of an aggregate class - * that it owns instances of it's members and these instances - * should not be shared. This is not reliably enforceable in C++ - * but this class attempts to make the 1-1 relationship clear. - * - * \section Example usage - * - * \code{.cpp} - * class foo { - * ...constructors accessors etc. - * int x[1000]; - * } - * - * class bar { - * public : - * static - * bar * - * New( - * ) { - * MEM_SmartPtr<foo> afoo = new foo(); - * MEM_SmartPtr<bar> that = new bar(); - * - * if (foo == NULL || that == NULL) return NULL; - * - * that->m_foo = afoo.Release(); - * return that.Release(); - * } - * - * ~bar() { - * // smart ptr takes care of deletion - * } - * private : - * MEM_SmartPtr<foo> m_foo; - * } - * \endcode - * - * You may also safely construct vectors of MEM_SmartPtrs and - * have the vector own stuff you put into it. - * - * e.g. - * \code{.cpp} - * { - * std::vector<MEM_SmartPtr<foo> > foo_vector; - * foo_vector.push_back( new foo()); - * foo_vector.push_back( new foo()); - * - * foo_vector[0]->bla(); - * } // foo_vector out of scope => heap memory freed for both foos - * \endcode - * - * @warning this class should only be used for objects created - * on the heap via the new function. It will not behave correctly - * if you pass ptrs to objects created with new[] nor with - * objects declared on the stack. Doing this is likely to crash - * the program or lead to memory leaks. - */ - -template - < class T > -class MEM_SmartPtr { - -public : - - /** - * Construction from reference - this class - * always assumes ownership from the rhs. - */ - - MEM_SmartPtr( - const MEM_SmartPtr &rhs - ) { - m_val = rhs.Release(); - } - - /** - * Construction from ptr - this class always - * assumes that it now owns the memory associated with the - * ptr. - */ - - MEM_SmartPtr( - T* val - ) : - m_val (val) - { - } - - /** - * Defalut constructor - */ - - MEM_SmartPtr( - ) : - m_val (NULL) - { - } - - /** - * Type conversion from this class to the type - * of a pointer to the template parameter. - * This means you can pass an instance of this class - * to a function expecting a ptr of type T. - */ - - operator T * () const { - return m_val; - } - - /** - * Return a reference to the internal ptr class. - * Use with care when you now that the internal ptr - * is not NULL! - */ - - T & - Ref( - ) const { - return *m_val; - } - - /** - * Assignment operator - ownership is transferred from rhs to lhs. - * There is an intenional side-effect of function of transferring - * ownership from the const parameter rhs. This is to insure - * the 1-1 relationship. - * The object associated with this instance is deleted if it - * is not the same as that contained in the rhs. - */ - - MEM_SmartPtr & operator=( - const MEM_SmartPtr &rhs - ) { - if (this->m_val != rhs.m_val) { - delete this->m_val; - } - - this->m_val = rhs.Release(); - return *this; - } - - /** - * Overload the operator -> so that it's possible to access - * all the normal methods of the internal ptr. - */ - - T * operator->() const { - return m_val; - } - - /** - * Caller takes ownership of the object - the object will not - * be deleted when the ptr goes out of scope. - */ - - T * - Release( - ) const { - T* temp = m_val; - (const_cast<MEM_SmartPtr *>(this))->m_val = NULL; - return temp; - } - - /** - * Force destruction of the internal object. - */ - - void - Delete( - ) { - delete (m_val); - m_val = NULL; - } - - /** - * Destructor - deletes object if it exists - */ - - ~MEM_SmartPtr( - ) { - delete (m_val); - } - -private : - - /// The ptr owned by this class. - T * m_val; -}; - -#endif - |