Amebis/wxWidgets
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Updated wxTrackable to patch Weak references for wx - part 2

Browse Source 
git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@51101 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775
This commit is contained in:
Robert Roebling
2008-01-08 09:58:44 +00:00
parent 9dd5ff5baa
commit 7d23dd2812
1 changed files with 83 additions and 79 deletions
Download Patch File Download Diff File Expand all files Collapse all files

136
include/wx/tracker.h
View File

@@ -3,7 +3,7 @@
// Purpose: Support class for object lifetime tracking (wxWeakRef<T>) // Purpose: Support class for object lifetime tracking (wxWeakRef<T>)
// Author: Arne Steinarson // Author: Arne Steinarson
// Created: 2007-12-28 // Created: 2007-12-28
// RCS-ID: $Id:$ // RCS-ID: $Id$
// Copyright: (c) 2007 Arne Steinarson // Copyright: (c) 2007 Arne Steinarson
// Licence: wxWindows licence // Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////
@@ -11,14 +11,14 @@
#ifndef _WX_TRACKER_H_ #ifndef _WX_TRACKER_H_
#define _WX_TRACKER_H_ #define _WX_TRACKER_H_
// This structure represents an object tracker and is stored in a linked list // This structure represents an object tracker and is stored in a linked list
// in the tracked object. It is only used in one of its derived forms. // in the tracked object. It is only used in one of its derived forms.
struct wxTrackerNode struct wxTrackerNode {
{ wxTrackerNode( ) : m_nxt(0) { }
wxTrackerNode() : m_next(NULL) { }
virtual ~wxTrackerNode() { } virtual ~wxTrackerNode() { }
virtual void OnObjectDestroy() = 0; virtual void OnObjectDestroy( ) = 0;
// This is to tell the difference between different tracker node types. // This is to tell the difference between different tracker node types.
// It's a replacement of dynamic_cast<> for this class since dynamic_cast // It's a replacement of dynamic_cast<> for this class since dynamic_cast
@@ -29,111 +29,115 @@ struct wxTrackerNode
virtual wxTrackerNodeType GetType() = 0; virtual wxTrackerNodeType GetType() = 0;
protected: protected:
wxTrackerNode *m_next; wxTrackerNode *m_nxt;
friend class wxTrackableBase; // For list access friend class wxTrackableBase; // For list access
friend class wxEvtHandler; // For list access friend class wxEvtHandler; // For list access
}; };
// Add-on base class for a trackable object. // Add-on base class for a trackable object.
struct wxTrackableBase struct wxTrackableBase {
{ wxTrackableBase() : m_first(0) { }
wxTrackableBase() : m_first(NULL) { }
~wxTrackableBase() ~wxTrackableBase()
{ {
// Notify all registered refs // Notify all registered refs
// OnObjectDestroy has to remove the item from the link chain wxTrackerNode *first;
while ( m_first ) while( m_first )
{ {
wxTrackerNode *first = m_first; first = m_first;
first->OnObjectDestroy(); first->OnObjectDestroy( );
RemoveNode(first); RemoveNode(first);
} }
} }
void AddNode(wxTrackerNode *node) void AddNode( wxTrackerNode *prn )
{ {
node->m_next = m_first; prn->m_nxt = m_first;
m_first = node; m_first = prn;
} }
void RemoveNode( wxTrackerNode *prn )
void RemoveNode(wxTrackerNode *node)
{ {
for ( wxTrackerNode **pn = &m_first; *pn; pn = &(*pn)->m_next ) for( wxTrackerNode **pprn=&m_first; *pprn; pprn=&(*pprn)->m_nxt )
{ {
if ( *pn == node ) if( *pprn==prn )
{ {
*pn = node->m_next; *pprn = prn->m_nxt;
return; return;
} }
} }
// Not found, an error.
wxFAIL_MSG( "node should be present" ); wxASSERT( false );
} }
wxTrackerNode *GetFirst() { return m_first; } wxTrackerNode* GetFirst( ){ return m_first; }
// If trying to copy this object, then do not copy its ref list.
wxTrackableBase& operator = (const wxTrackableBase& other) { return *this; }
protected: protected:
wxTrackerNode *m_first; wxTrackerNode *m_first;
}; };
// The difference to wxTrackableBase is that this class adds // The difference to wxTrackableBase is that this class adds
// a VTable to enable dynamic_cast query for wxTrackable. // a VTable to enable dynamic_cast query for wxTrackable.
struct wxTrackable : wxTrackableBase struct wxTrackable : public wxTrackableBase
{ {
virtual ~wxTrackable() { } virtual ~wxTrackable(){ }
}; };
// Helper to decide if an object has a base class or not // Helper to decide if an object has a base class or not
// (strictly speaking, this test succeeds if a type is convertible // (strictly speaking, this test succeeds if a type is convertible
// to another type in some way.) // to another type in some way.)
template <class T, class B> template<class T, class B>
struct wxHasBase struct wxHasBase{
{ static char Match( B* pb );
static char Match(B *pb); static int Match( ... );
static int Match(...); enum { value = (sizeof(Match((T*)NULL))==sizeof(char)) };
enum { value = sizeof(Match((T*)NULL)) == sizeof(char) };
}; };
// A structure to cast to wxTrackableBase, using either static_cast<> or // VC++ before 7.1 does not have partial template specialization
// dynamic_cast<>. #ifdef __VISUALC__
template <class T, bool is_static> #if __VISUALC__ < 1310
struct wxTrackableCaster; #define HAVE_NO_PARTIAL_SPECIALIZATION
#endif
#endif
template <class T> #if defined(HAVE_DYNAMIC_CAST) && !defined(HAVE_NO_PARTIAL_SPECIALIZATION)
struct wxTrackableCaster<T, true> // A structure to cast to wxTrackableBase, using either static_cast<> or dynamic_cast<>.
{ template<class T,bool is_static>
static wxTrackableBase* Cast(T* pt) struct wxTrackableCaster;
{
return static_cast<wxTrackableBase *>(pt);
}
};
#ifdef HAVE_DYNAMIC_CAST template <class T>
struct wxTrackableCaster<T,true> {
static wxTrackableBase* Cast(T* pt){ return static_cast<wxTrackableBase*>(pt); }
};
template <class T> template <class T>
struct wxTrackableCaster<T, false> struct wxTrackableCaster<T,false> {
{ static wxTrackableBase* Cast(T* pt){ return dynamic_cast<wxTrackableBase*>(pt); }
static wxTrackableBase *Cast(T* pt) };
{ #else
return dynamic_cast<wxTrackableBase *>(pt); #if defined(HAVE_DYNAMIC_CAST)
} // If we have dynamic_cast, default to that. For gcc, dynamic_cast<> does the job
}; // of both the dynamic and the static case. It could be that all compilers do it
// that way, rendering the specialization code above rednundant.
#else // !HAVE_DYNAMIC_CAST template <class T,bool is_static>
struct wxTrackableCaster {
template <class T> static wxTrackableBase* Cast(T* pt){ return dynamic_cast<wxTrackableBase*>(pt); }
struct wxTrackableCaster<T, false> };
{ #else
static wxTrackableBase *Cast(T* pt) { return NULL; } // No dynamic_cast<> is available.
}; // We use static_cast<>, that gives support for wxEvtHandler and wxWindow references.
// We don't get weak refs to other wxObject derived types.
#endif // HAVE_DYNAMIC_CAST/!HAVE_DYNAMIC_CAST template <class T,bool is_static>
struct wxTrackableCaster {
static wxTrackableBase* Cast(T* pt){ return static_cast<wxTrackableBase*>(pt); }
};
#endif
#endif
#endif // _WX_TRACKER_H_ #endif // _WX_TRACKER_H_