#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 a 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"
enum { value = wxConvertibleTo<T, wxTrackable>::value };
};
+#endif // !USE_ONLY_STATIC_WEAKREF
+
+
// Weak ref implementation when T has wxTrackable as a known base class
template <class T>
class wxWeakRefStatic : public wxTrackerNode
}
}
+ virtual void OnObjectDestroy()
+ {
+ // Tracked object itself removes us from list of trackers
+ wxASSERT(m_pobj != NULL);
+ m_pobj = NULL;
+ }
+
protected:
void Assign(T* pobj)
{
}
}
- void AssignCopy( const wxWeakRefStatic& wr )
+ void AssignCopy(const wxWeakRefStatic& wr)
{
Assign( wr.m_pobj );
}
- virtual void OnObjectDestroy()
- {
- // Tracked object itself removes us from list of trackers
- wxASSERT( m_pobj!=NULL );
- m_pobj = NULL;
- }
-
T *m_pobj;
};
-#ifdef HAVE_PARTIAL_SPECIALIZATION
+
+
+#ifndef USE_ONLY_STATIC_WEAKREF
template<class T,bool use_static>
struct wxWeakRefImpl;
}
}
+ virtual void OnObjectDestroy()
+ {
+ // Tracked object itself removes us from list of trackers
+ wxASSERT(m_pobj != NULL);
+ m_pobj = NULL;
+ m_ptbase = NULL;
+ }
+
protected:
wxWeakRefImpl() : m_pobj(NULL), m_ptbase(NULL) { }
DoAssign( pobj, ptbase );
}
-#ifdef HAVE_DYNAMIC_CAST
+#ifndef wxNO_RTTI
void AssignHelper(T* pobj, wxInt2Type<false>)
{
// A last way to get a trackable pointer
Release();
}
}
-#endif // HAVE_DYNAMIC_CAST
+#endif // RTTI enabled
void AssignCopy(const wxWeakRefImpl& wr)
{
- DoAssign( wr.m_pobj, wr.m_ptbase );
+ DoAssign(wr.m_pobj, wr.m_ptbase);
}
void DoAssign( T* pobj, wxTrackable *ptbase ) {
}
}
- virtual void OnObjectDestroy()
- {
- // Tracked object itself removes us from list of trackers
- wxASSERT( m_pobj!=NULL );
- m_pobj = NULL;
- m_ptbase = NULL;
- }
-
T *m_pobj;
wxTrackable *m_ptbase;
};
-#endif // HAVE_PARTIAL_SPECIALIZATION
+#endif // #ifndef USE_ONLY_STATIC_WEAKREF
+
-// A weak reference to an object of type T, where T has type wxTrackable
+// 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 HAVE_PARTIAL_SPECIALIZATION
- wxWeakRefImpl<T, wxIsStaticTrackable<T>::value>
-#else
+#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)
+ {
+ 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>
Assign(pobj);
}
- template <class TDerived>
- wxWeakRef<T>& operator=(TDerived* 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)
{
- Assign(pobj);
- return *this;
+ Assign(wr.get());
}
wxWeakRef<T>& operator=(const wxWeakRef<T>& wr)
return *this;
}
- virtual ~wxWeakRef() { Release(); }
+ virtual ~wxWeakRef() { this->Release(); }
// Smart pointer functions
- T& operator*() const { return *m_pobj; }
- T* operator->() const { return m_pobj; }
-
- T* get() const { return m_pobj; }
+ T& operator*() const { return *this->m_pobj; }
+ T* operator->() const { return this->m_pobj; }
- // test for pointer validity: defining conversion to unspecified_bool_type
- // and not more obvious bool to avoid implicit conversions to integer types
- typedef T *(wxWeakRef<T>::*unspecified_bool_type)() const;
- operator unspecified_bool_type() const
- {
- return this->m_pobj ? &wxWeakRef<T>::get : NULL;
- }
+ T* get() const { return this->m_pobj; }
+ operator T*() const { return this->m_pobj; }
};
+#ifndef wxNO_RTTI
+
// Weak ref implementation assign objects are queried for wxTrackable
// using dynamic_cast<>
-template<class T>
+template <class T>
class wxWeakRefDynamic : public wxTrackerNode
{
public:
Assign(pobj);
}
+ wxWeakRefDynamic(const wxWeakRef<T>& wr)
+ {
+ Assign(wr.get());
+ }
+
virtual ~wxWeakRefDynamic() { Release(); }
// Smart pointer functions
- T& operator * (){ wxASSERT(this->m_pobj); return *m_pobj; }
- T* operator -> (){ wxASSERT(this->m_pobj); return m_pobj; }
- T* operator = (T* pobj) { Assign(pobj); return m_pobj; }
-
- T* get(){ return this->m_pobj; }
+ T& operator*() const { wxASSERT(m_pobj); return *m_pobj; }
+ T* operator->() const { wxASSERT(m_pobj); return m_pobj; }
- // operator T* (){ return this->m_pobj; }
+ T* get() const { return m_pobj; }
+ operator T* () const { return m_pobj; }
- // test for pointer validity: defining conversion to unspecified_bool_type
- // and not more obvious bool to avoid implicit conversions to integer types
- typedef T *(wxWeakRef<T>::*unspecified_bool_type)() const;
- operator unspecified_bool_type() const
- {
- return m_pobj ? &wxWeakRef<T>::get : NULL;
- }
+ T* operator = (T* pobj) { Assign(pobj); return m_pobj; }
// Assign from another weak ref, point to same object
- T* operator = (const wxWeakRef<T> &wr) { Assign( wr.get() ); return this->m_pobj; }
+ T* operator = (const wxWeakRef<T> &wr) { Assign( wr.get() ); return m_pobj; }
void Release()
{
}
}
+ virtual void OnObjectDestroy()
+ {
+ wxASSERT_MSG(m_pobj, "tracked object should have removed us itself");
+
+ m_pobj = NULL;
+ }
+
protected:
void Assign(T *pobj)
{
}
}
- void AssignCopy(const wxWeakRefDynamic& wr)
- {
- Assign(wr.m_pobj);
- }
-
- virtual void OnObjectDestroy()
- {
- wxASSERT_MSG( m_pobj, "tracked object should have removed us itself" );
-
- m_pobj = NULL;
- }
-
T *m_pobj;
};
+#endif // RTTI enabled
+
+
// Provide some basic types of weak references
class WXDLLIMPEXP_FWD_BASE wxEvtHandler;
-class WXDLLIMPEXP_FWD_BASE wxWindow;
+class WXDLLIMPEXP_FWD_CORE wxWindow;
+
typedef wxWeakRef<wxEvtHandler> wxEvtHandlerRef;
typedef wxWeakRef<wxWindow> wxWindowRef;
projects / wxWidgets.git / blobdiff