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

Use the same wxWeakRef implementation for complete and incomplete classes.

Browse Source 
This fixes an ODR violation which could arise if wxWeakRef<T> was seen both
when T was an incomplete (e.g. just forward-defined) class and when it was
complete. As different implementations, with different binary layouts, were
used in these two cases, this resulted in fatal run-time problems.

Fix this by always using the slightly less efficient (because storing an extra
pointer) but simpler and safe "dynamic" wxWeakRef implementation.

Also get rid of checks for the ancient compilers such as VC6 and g++ < 3.3,
they are not supported any longer.

Closes #15884.

git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@76316 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775
This commit is contained in:
Vadim Zeitlin
2014-04-12 00:10:54 +00:00
parent 0ed46e37fa
commit 72aad0d6ea
4 changed files with 75 additions and 164 deletions
Download Patch File Download Diff File Expand all files Collapse all files

201
include/wx/weakref.h
View File

@@ -13,22 +13,6 @@
#include "wx/tracker.h"
// Some compilers (VC6, Borland, g++ < 3.3) have problem with template specialization.
// However, this is only used for optimization purposes (a smaller wxWeakRef pointer)
// (and the corner case of wxWeakRef<wxObject>). So for those compilers, we can fall
// back to the non-optimal case, where we use the same type of weak ref (static one)
// in all cases. See defs.h for various setting these defines depending on compiler.
#if !defined(HAVE_PARTIAL_SPECIALIZATION) || \
!defined(HAVE_TEMPLATE_OVERLOAD_RESOLUTION) || \
(defined(__GNUC__) && !wxCHECK_GCC_VERSION(3, 3))
#define USE_ONLY_STATIC_WEAKREF
#endif
#ifndef USE_ONLY_STATIC_WEAKREF
// Avoid including this for simpler compilers
#include "wx/meta/convertible.h"
#include "wx/meta/int2type.h"
@@ -38,79 +22,55 @@ struct wxIsStaticTrackable
enum { value = wxConvertibleTo<T, wxTrackable>::value };
};
#endif // !USE_ONLY_STATIC_WEAKREF
// Weak ref implementation when T has wxTrackable as a known base class
// A weak reference to an object of type T (which must inherit from wxTrackable)
template <class T>
class wxWeakRefStatic : public wxTrackerNode
class wxWeakRef : public wxTrackerNode
{
public:
wxWeakRefStatic() : m_pobj(NULL) { }
typedef T element_type;
void Release()
// Default ctor
wxWeakRef() : m_pobj(NULL), m_ptbase(NULL) { }
// Ctor from the object of this type: this is needed as the template ctor
// below is not used by at least g++4 when a literal NULL is used
wxWeakRef(T *pobj) : m_pobj(NULL), m_ptbase(NULL)
{
// Release old object if any
if ( m_pobj )
{
// Remove ourselves from object tracker list
wxTrackable *pt = static_cast<wxTrackable*>(m_pobj);
pt->RemoveNode(this);
m_pobj = NULL;
}
this->Assign(pobj);
}
virtual void OnObjectDestroy() wxOVERRIDE
// When we have the full type here, static_cast<> will always work
// (or give a straight compiler error).
template <class TDerived>
wxWeakRef(TDerived* pobj) : m_pobj(NULL), m_ptbase(NULL)
{
// Tracked object itself removes us from list of trackers
wxASSERT(m_pobj != NULL);
m_pobj = NULL;
this->Assign(pobj);
}
protected:
void Assign(T* pobj)
// We need this copy ctor, since otherwise a default compiler (binary) copy
// happens (if embedded as an object member).
wxWeakRef(const wxWeakRef<T>& wr) : m_pobj(NULL), m_ptbase(NULL)
{
if ( m_pobj == pobj )
return;
Release();
// Now set new trackable object
if ( pobj )
{
// Add ourselves to object tracker list
wxTrackable *pt = static_cast<wxTrackable*>(pobj);
pt->AddNode(this);
m_pobj = pobj;
}
this->Assign(wr.get());
}
void AssignCopy(const wxWeakRefStatic& wr)
wxWeakRef<T>& operator=(const wxWeakRef<T>& wr)
{
Assign( wr.m_pobj );
this->AssignCopy(wr);
return *this;
}
T *m_pobj;
};
virtual ~wxWeakRef() { this->Release(); }
// Smart pointer functions
T& operator*() const { return *this->m_pobj; }
T* operator->() const { return this->m_pobj; }
T* get() const { return this->m_pobj; }
operator T*() const { return this->m_pobj; }
#ifndef USE_ONLY_STATIC_WEAKREF
template<class T,bool use_static>
struct wxWeakRefImpl;
// Intermediate class, to select the static case above.
template <class T>
struct wxWeakRefImpl<T, true> : public wxWeakRefStatic<T>
{
enum { value = 1 };
};
// Weak ref implementation when T does not have wxTrackable as known base class
template<class T>
struct wxWeakRefImpl<T, false> : public wxTrackerNode
{
public:
void Release()
{
// Release old object if any
@@ -132,51 +92,30 @@ struct wxWeakRefImpl<T, false> : public wxTrackerNode
}
protected:
wxWeakRefImpl() : m_pobj(NULL), m_ptbase(NULL) { }
// Assign receives most derived class here and can use that
template <class TDerived>
void Assign( TDerived* pobj )
{
AssignHelper( pobj, wxInt2Type<wxIsStaticTrackable<TDerived>::value>() );
}
template <class TDerived>
void AssignHelper(TDerived* pobj, wxInt2Type<true>)
{
wxCOMPILE_TIME_ASSERT( wxIsStaticTrackable<TDerived>::value,
Tracked_class_should_inherit_from_wxTrackable );
wxTrackable *ptbase = static_cast<wxTrackable*>(pobj);
DoAssign( pobj, ptbase );
DoAssign(pobj, ptbase);
}
#ifndef wxNO_RTTI
void AssignHelper(T* pobj, wxInt2Type<false>)
{
// A last way to get a trackable pointer
wxTrackable *ptbase = dynamic_cast<wxTrackable*>(pobj);
if ( ptbase )
{
DoAssign( pobj, ptbase );
}
else
{
wxFAIL_MSG( "Tracked class should inherit from wxTrackable" );
Release();
}
}
#endif // RTTI enabled
void AssignCopy(const wxWeakRefImpl& wr)
void AssignCopy(const wxWeakRef& wr)
{
DoAssign(wr.m_pobj, wr.m_ptbase);
}
void DoAssign( T* pobj, wxTrackable *ptbase ) {
if( m_pobj==pobj ) return;
void DoAssign(T* pobj, wxTrackable *ptbase)
{
if ( m_pobj == pobj )
return;
Release();
// Now set new trackable object
if( pobj )
if ( pobj )
{
// Add ourselves to object tracker list
wxASSERT( ptbase );
@@ -190,68 +129,6 @@ protected:
wxTrackable *m_ptbase;
};
#endif // #ifndef USE_ONLY_STATIC_WEAKREF
// A weak reference to an object of type T, where T has base wxTrackable
// (usually statically but if not dynamic_cast<> is tried).
template <class T>
class wxWeakRef : public
#ifdef USE_ONLY_STATIC_WEAKREF
wxWeakRefStatic<T>
#else
wxWeakRefImpl<T, wxIsStaticTrackable<T>::value != 0>
#endif
{
public:
typedef T element_type;
// Default ctor
wxWeakRef() { }
// Enabling this ctor for VC6 results in mysterious compilation failures in
// wx/window.h when assigning wxWindow pointers (FIXME-VC6)
#ifndef __VISUALC6__
// Ctor from the object of this type: this is needed as the template ctor
// below is not used by at least g++4 when a literal NULL is used
wxWeakRef(T *pobj)
{
this->Assign(pobj);
}
#endif // !__VISUALC6__
// When we have the full type here, static_cast<> will always work
// (or give a straight compiler error).
template <class TDerived>
wxWeakRef(TDerived* pobj)
{
this->Assign(pobj);
}
// We need this copy ctor, since otherwise a default compiler (binary) copy
// happens (if embedded as an object member).
wxWeakRef(const wxWeakRef<T>& wr)
{
this->Assign(wr.get());
}
wxWeakRef<T>& operator=(const wxWeakRef<T>& wr)
{
this->AssignCopy(wr);
return *this;
}
virtual ~wxWeakRef() { this->Release(); }
// Smart pointer functions
T& operator*() const { return *this->m_pobj; }
T* operator->() const { return this->m_pobj; }
T* get() const { return this->m_pobj; }
operator T*() const { return this->m_pobj; }
};
#ifndef wxNO_RTTI