[wxWidgets.git] / include / wx / ptr_scpd.h

/////////////////////////////////////////////////////////////////////////////
// Name:        wx/ptr_scpd.h
// Purpose:     scoped smart pointer class
// Author:      Jesse Lovelace <jllovela@eos.ncsu.edu>
// Modified by:
// Created:     06/01/02
// RCS-ID:      $Id$
// Copyright:   (c) Jesse Lovelace and original Boost authors (see below)
// Licence:     wxWindows licence
/////////////////////////////////////////////////////////////////////////////

//  This class closely follows the implementation of the boost
//  library scoped_ptr and is an adaption for c++ macro's in
//  the wxWidgets project. The original authors of the boost
//  scoped_ptr are given below with their respective copyrights.

//  (C) Copyright Greg Colvin and Beman Dawes 1998, 1999.
//  Copyright (c) 2001, 2002 Peter Dimov
//
//  Permission to copy, use, modify, sell and distribute this software
//  is granted provided this copyright notice appears in all copies.
//  This software is provided "as is" without express or implied
//  warranty, and with no claim as to its suitability for any purpose.
//
//  See http://www.boost.org/libs/smart_ptr/scoped_ptr.htm for documentation.
//

#ifndef __WX_SCOPED_POINTER__
#define __WX_SCOPED_POINTER__

#include "wx/defs.h"

/*
   checked deleters are used to make sure that the type being deleted is really
   a complete type.: otherwise sizeof() would result in a compile-time error

   do { ... } while ( 0 ) construct is used to have an anonymous scope
   (otherwise we could have name clashes between different "complete"s) but
   still force a semicolon after the macro
*/

#ifdef __WATCOMC__
    #define wxFOR_ONCE(name)              for(int name=0; name<1; name++)
    #define wxPRE_NO_WARNING_SCOPE(name)  wxFOR_ONCE(wxMAKE_UNIQUE_NAME(name))
    #define wxPOST_NO_WARNING_SCOPE(name)
#else
    #define wxPRE_NO_WARNING_SCOPE(name)  do
    #define wxPOST_NO_WARNING_SCOPE(name) while ( 0 )
#endif

#define wxCHECKED_DELETE(ptr)                                                 \
    wxPRE_NO_WARNING_SCOPE(scope_var1)                                        \
    {                                                                         \
        typedef char complete[sizeof(*ptr)];                                  \
        delete ptr;                                                           \
    } wxPOST_NO_WARNING_SCOPE(scope_var1)

#define wxCHECKED_DELETE_ARRAY(ptr)                                           \
    wxPRE_NO_WARNING_SCOPE(scope_var2)                                        \
    {                                                                         \
        typedef char complete[sizeof(*ptr)];                                  \
        delete [] ptr;                                                        \
    } wxPOST_NO_WARNING_SCOPE(scope_var2)

/* These scoped pointers are *not* assignable and cannot be used
   within a container.  Look for wxDECLARE_SHARED_PTR for this
   functionality.

   In addition, the type being used *must* be complete at the time
   that wxDEFINE_SCOPED_* is called or a compiler error will result.
   This is because the class checks for the completeness of the type
   being used.
*/


#define wxDECLARE_SCOPED_PTR(T, name) \
class name                          \
{                                   \
private:                            \
    T * m_ptr;                      \
                                    \
    name(name const &);             \
    name & operator=(name const &); \
                                    \
public:                             \
    wxEXPLICIT name(T * ptr = NULL) \
    : m_ptr(ptr) { }                \
                                    \
    ~name();                        \
                                    \
    void reset(T * ptr = NULL)      \
    {                               \
        if (m_ptr != ptr)           \
        {                           \
            delete m_ptr;           \
            m_ptr = ptr;            \
        }                           \
    }                               \
                                    \
    T *release()                    \
    {                               \
        T *ptr = m_ptr;             \
        m_ptr = NULL;               \
        return ptr;                 \
    }                               \
                                    \
    T & operator*() const           \
    {                               \
        wxASSERT(m_ptr != NULL);    \
        return *m_ptr;              \
    }                               \
                                    \
    T * operator->() const          \
    {                               \
        wxASSERT(m_ptr != NULL);    \
        return m_ptr;               \
    }                               \
                                    \
    T * get() const                 \
    {                               \
        return m_ptr;               \
    }                               \
                                    \
    void swap(name & ot)            \
    {                               \
        T * tmp = ot.m_ptr;         \
        ot.m_ptr = m_ptr;           \
        m_ptr = tmp;                \
    }                               \
};

#define wxDEFINE_SCOPED_PTR(T, name)\
name::~name()                       \
{                                   \
    wxCHECKED_DELETE(m_ptr);        \
}

// this macro can be used for the most common case when you want to declare and
// define the scoped pointer at the same time and want to use the standard
// naming convention: auto pointer to Foo is called FooPtr
#define wxDEFINE_SCOPED_PTR_TYPE(T)                                           \
    wxDECLARE_SCOPED_PTR(T, T ## Ptr);                                        \
    wxDEFINE_SCOPED_PTR(T, T ## Ptr)

// the same but for arrays instead of simple pointers
#define wxDECLARE_SCOPED_ARRAY(T, name)\
class name                          \
{                                   \
private:                            \
    T * m_ptr;                      \
    name(name const &);             \
    name & operator=(name const &); \
                                    \
public:                             \
    wxEXPLICIT name(T * p = NULL) : m_ptr(p) \
    {}                              \
                                    \
    ~name();                        \
    void reset(T * p = NULL);       \
                                    \
    T & operator[](long int i) const\
    {                               \
        wxASSERT(m_ptr != NULL);    \
        wxASSERT(i >= 0);           \
        return m_ptr[i];            \
    }                               \
                                    \
    T * get() const                 \
    {                               \
        return m_ptr;               \
    }                               \
                                    \
    void swap(name & ot)            \
    {                               \
        T * tmp = ot.m_ptr;         \
        ot.m_ptr = m_ptr;           \
        m_ptr = tmp;                \
    }                               \
};

#define wxDEFINE_SCOPED_ARRAY(T, name)  \
name::~name()                           \
{                                       \
    wxCHECKED_DELETE_ARRAY(m_ptr);      \
}                                       \
void name::reset(T * p){                \
    if (m_ptr != p)                     \
    {                                   \
       wxCHECKED_DELETE_ARRAY(m_ptr);   \
       m_ptr = p;                       \
    }                                   \
}

// ----------------------------------------------------------------------------
// "Tied" scoped pointer: same as normal one but also sets the value of
//                        some other variable to the pointer value
// ----------------------------------------------------------------------------

#define wxDEFINE_TIED_SCOPED_PTR_TYPE(T)                                      \
    wxDEFINE_SCOPED_PTR_TYPE(T);                                              \
    class T ## TiedPtr : public T ## Ptr                                      \
    {                                                                         \
    public:                                                                   \
        T ## TiedPtr(T **pp, T *p)                                            \
            : T ## Ptr(p), m_pp(pp)                                           \
        {                                                                     \
            m_pOld = *pp;                                                     \
            *pp = p;                                                          \
        }                                                                     \
                                                                              \
        ~ T ## TiedPtr()                                                      \
        {                                                                     \
            *m_pp = m_pOld;                                                   \
        }                                                                     \
                                                                              \
    private:                                                                  \
        T **m_pp;                                                             \
        T *m_pOld;                                                            \
    }

#endif // __WX_SCOPED_POINTER__
Commit	Line	Data
5b222f1c JS	1	/////////////////////////////////////////////////////////////////////////////
	2	// Name: wx/ptr_scpd.h
	3	// Purpose: scoped smart pointer class
	4	// Author: Jesse Lovelace <jllovela@eos.ncsu.edu>
	5	// Modified by:
	6	// Created: 06/01/02
	7	// RCS-ID: $Id$
	8	// Copyright: (c) Jesse Lovelace and original Boost authors (see below)
65571936	9	// Licence: wxWindows licence
5b222f1c JS	10	/////////////////////////////////////////////////////////////////////////////
	11
	12	// This class closely follows the implementation of the boost
7e548f6b	13	// library scoped_ptr and is an adaption for c++ macro's in
77ffb593	14	// the wxWidgets project. The original authors of the boost
5b222f1c JS	15	// scoped_ptr are given below with their respective copyrights.
	16
	17	// (C) Copyright Greg Colvin and Beman Dawes 1998, 1999.
	18	// Copyright (c) 2001, 2002 Peter Dimov
	19	//
	20	// Permission to copy, use, modify, sell and distribute this software
	21	// is granted provided this copyright notice appears in all copies.
	22	// This software is provided "as is" without express or implied
	23	// warranty, and with no claim as to its suitability for any purpose.
	24	//
	25	// See http://www.boost.org/libs/smart_ptr/scoped_ptr.htm for documentation.
	26	//
	27
	28	#ifndef __WX_SCOPED_POINTER__
	29	#define __WX_SCOPED_POINTER__
	30
	31	#include "wx/defs.h"
	32
d566b182 VZ	33	/*
	34	checked deleters are used to make sure that the type being deleted is really
	35	a complete type.: otherwise sizeof() would result in a compile-time error
	36
	37	do { ... } while ( 0 ) construct is used to have an anonymous scope
	38	(otherwise we could have name clashes between different "complete"s) but
	39	still force a semicolon after the macro
5b222f1c JS	40	*/
5b222f1c JS	41
373a5fb3	42	#ifdef __WATCOMC__
5c519b6c WS	43	#define wxFOR_ONCE(name) for(int name=0; name<1; name++)
	44	#define wxPRE_NO_WARNING_SCOPE(name) wxFOR_ONCE(wxMAKE_UNIQUE_NAME(name))
	45	#define wxPOST_NO_WARNING_SCOPE(name)
373a5fb3	46	#else
5c519b6c WS	47	#define wxPRE_NO_WARNING_SCOPE(name) do
5c519b6c WS	48	#define wxPOST_NO_WARNING_SCOPE(name) while ( 0 )
373a5fb3 WS	49	#endif
373a5fb3 WS	50
d566b182	51	#define wxCHECKED_DELETE(ptr) \
5c519b6c	52	wxPRE_NO_WARNING_SCOPE(scope_var1) \
d566b182 VZ	53	{ \
	54	typedef char complete[sizeof(*ptr)]; \
	55	delete ptr; \
5c519b6c	56	} wxPOST_NO_WARNING_SCOPE(scope_var1)
d566b182 VZ	57
d566b182 VZ	58	#define wxCHECKED_DELETE_ARRAY(ptr) \
5c519b6c	59	wxPRE_NO_WARNING_SCOPE(scope_var2) \
d566b182 VZ	60	{ \
	61	typedef char complete[sizeof(*ptr)]; \
	62	delete [] ptr; \
5c519b6c	63	} wxPOST_NO_WARNING_SCOPE(scope_var2)
5b222f1c JS	64
	65	/* These scoped pointers are not assignable and cannot be used
	66	within a container. Look for wxDECLARE_SHARED_PTR for this
	67	functionality.
	68
	69	In addition, the type being used must be complete at the time
	70	that wxDEFINE_SCOPED_* is called or a compiler error will result.
	71	This is because the class checks for the completeness of the type
	72	being used.
	73	*/
	74
	75
	76	#define wxDECLARE_SCOPED_PTR(T, name) \
	77	class name \
	78	{ \
	79	private: \
	80	T * m_ptr; \
	81	\
	82	name(name const &); \
	83	name & operator=(name const &); \
	84	\
	85	public: \
5455e227	86	wxEXPLICIT name(T * ptr = NULL) \
5b222f1c JS	87	: m_ptr(ptr) { } \
	88	\
	89	~name(); \
	90	\
	91	void reset(T * ptr = NULL) \
	92	{ \
	93	if (m_ptr != ptr) \
	94	{ \
	95	delete m_ptr; \
	96	m_ptr = ptr; \
	97	} \
	98	} \
	99	\
5455e227 VZ	100	T *release() \
	101	{ \
	102	T *ptr = m_ptr; \
	103	m_ptr = NULL; \
	104	return ptr; \
	105	} \
	106	\
5b222f1c JS	107	T & operator*() const \
	108	{ \
	109	wxASSERT(m_ptr != NULL); \
	110	return *m_ptr; \
	111	} \
	112	\
	113	T * operator->() const \
	114	{ \
	115	wxASSERT(m_ptr != NULL); \
	116	return m_ptr; \
	117	} \
	118	\
	119	T * get() const \
	120	{ \
	121	return m_ptr; \
	122	} \
	123	\
	124	void swap(name & ot) \
	125	{ \
	126	T * tmp = ot.m_ptr; \
	127	ot.m_ptr = m_ptr; \
	128	m_ptr = tmp; \
	129	} \
	130	};
	131
	132	#define wxDEFINE_SCOPED_PTR(T, name)\
	133	name::~name() \
	134	{ \
bb0a3c4a	135	wxCHECKED_DELETE(m_ptr); \
5b222f1c JS	136	}
5b222f1c JS	137
d83eeece VZ	138	// this macro can be used for the most common case when you want to declare and
	139	// define the scoped pointer at the same time and want to use the standard
	140	// naming convention: auto pointer to Foo is called FooPtr
	141	#define wxDEFINE_SCOPED_PTR_TYPE(T) \
	142	wxDECLARE_SCOPED_PTR(T, T ## Ptr); \
	143	wxDEFINE_SCOPED_PTR(T, T ## Ptr)
	144
	145	// the same but for arrays instead of simple pointers
5b222f1c JS	146	#define wxDECLARE_SCOPED_ARRAY(T, name)\
	147	class name \
	148	{ \
	149	private: \
	150	T * m_ptr; \
	151	name(name const &); \
	152	name & operator=(name const &); \
	153	\
	154	public: \
	155	wxEXPLICIT name(T * p = NULL) : m_ptr(p) \
	156	{} \
	157	\
	158	~name(); \
	159	void reset(T * p = NULL); \
	160	\
	161	T & operator[](long int i) const\
	162	{ \
	163	wxASSERT(m_ptr != NULL); \
	164	wxASSERT(i >= 0); \
	165	return m_ptr[i]; \
	166	} \
	167	\
	168	T * get() const \
	169	{ \
	170	return m_ptr; \
	171	} \
	172	\
	173	void swap(name & ot) \
	174	{ \
	175	T * tmp = ot.m_ptr; \
	176	ot.m_ptr = m_ptr; \
	177	m_ptr = tmp; \
	178	} \
	179	};
	180
	181	#define wxDEFINE_SCOPED_ARRAY(T, name) \
bb0a3c4a VZ	182	name::~name() \
	183	{ \
	184	wxCHECKED_DELETE_ARRAY(m_ptr); \
	185	} \
	186	void name::reset(T * p){ \
	187	if (m_ptr != p) \
	188	{ \
	189	wxCHECKED_DELETE_ARRAY(m_ptr); \
	190	m_ptr = p; \
	191	} \
5b222f1c JS	192	}
5b222f1c JS	193
38f15267 VZ	194	// ----------------------------------------------------------------------------
	195	// "Tied" scoped pointer: same as normal one but also sets the value of
	196	// some other variable to the pointer value
	197	// ----------------------------------------------------------------------------
	198
	199	#define wxDEFINE_TIED_SCOPED_PTR_TYPE(T) \
	200	wxDEFINE_SCOPED_PTR_TYPE(T); \
	201	class T ## TiedPtr : public T ## Ptr \
	202	{ \
	203	public: \
	204	T ## TiedPtr(T *pp, T p) \
	205	: T ## Ptr(p), m_pp(pp) \
	206	{ \
	207	m_pOld = *pp; \
	208	*pp = p; \
	209	} \
	210	\
	211	~ T ## TiedPtr() \
	212	{ \
	213	*m_pp = m_pOld; \
	214	} \
	215	\
	216	private: \
	217	T **m_pp; \
	218	T *m_pOld; \
	219	}
	220
d83eeece VZ	221	#endif // __WX_SCOPED_POINTER__
d83eeece VZ	222