include/wx/weakref.h

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        wx/weakref.h
   3 // Purpose:     wxWeakRef - Generic weak references for wxWidgets
   4 // Author:      Arne Steinarson
   5 // Created:     27 Dec 07
   6 // RCS-ID:      $Id$
   7 // Copyright:   (c) 2007 Arne Steinarson
   8 // Licence:     wxWindows licence
   9 /////////////////////////////////////////////////////////////////////////////
  10
  11 #ifndef _WX_WEAKREF_H_
  12 #define _WX_WEAKREF_H_
  13
  14 #include "wx/tracker.h"
  15
  16
  17 // Some compilers (VC6, Borland, g++ < 3.3) have problem with template specialization.
  18 // However, this is only used for optimization purposes (a smaller wxWeakRef pointer)
  19 // (and the corner case of wxWeakRef<wxObject>). So for those compilers, we can fall
  20 // back to the non-optimal case, where we use a the same type of weak ref (static one)
  21 // in all cases. See defs.h for various setting these defines depending on compiler.
  22
  23 #if !defined(HAVE_PARTIAL_SPECIALIZATION) || \
  24     !defined(HAVE_TEMPLATE_OVERLOAD_RESOLUTION) || \
  25     (defined(__GNUC__) && !wxCHECK_GCC_VERSION(3, 3))
  26     #define USE_ONLY_STATIC_WEAKREF
  27 #endif
  28
  29
  30 #ifndef USE_ONLY_STATIC_WEAKREF
  31
  32 // Avoid including this for simpler compilers
  33 #include "wx/meta/convertible.h"
  34 #include "wx/meta/int2type.h"
  35
  36 template <class T>
  37 struct wxIsStaticTrackable
  38 {
  39     enum { value = wxConvertibleTo<T, wxTrackable>::value };
  40 };
  41
  42 #endif // !USE_ONLY_STATIC_WEAKREF
  43
  44
  45 // Weak ref implementation when T has wxTrackable as a known base class
  46 template <class T>
  47 class wxWeakRefStatic : public wxTrackerNode
  48 {
  49 public:
  50     wxWeakRefStatic() : m_pobj(NULL) { }
  51
  52     void Release()
  53     {
  54         // Release old object if any
  55         if ( m_pobj )
  56         {
  57             // Remove ourselves from object tracker list
  58             wxTrackable *pt = static_cast<wxTrackable*>(m_pobj);
  59             pt->RemoveNode(this);
  60             m_pobj = NULL;
  61         }
  62     }
  63
  64     virtual void OnObjectDestroy()
  65     {
  66         // Tracked object itself removes us from list of trackers
  67         wxASSERT(m_pobj != NULL);
  68         m_pobj = NULL;
  69     }
  70
  71 protected:
  72     void Assign(T* pobj)
  73     {
  74         if ( m_pobj == pobj )
  75             return;
  76
  77         Release();
  78
  79         // Now set new trackable object
  80         if ( pobj )
  81         {
  82             // Add ourselves to object tracker list
  83             wxTrackable *pt = static_cast<wxTrackable*>(pobj);
  84             pt->AddNode(this);
  85             m_pobj = pobj;
  86         }
  87     }
  88
  89     void AssignCopy(const wxWeakRefStatic& wr)
  90     {
  91         Assign( wr.m_pobj );
  92     }
  93
  94     T *m_pobj;
  95 };
  96
  97
  98
  99 #ifndef USE_ONLY_STATIC_WEAKREF
 100
 101 template<class T,bool use_static>
 102 struct wxWeakRefImpl;
 103
 104 // Intermediate class, to select the static case above.
 105 template <class T>
 106 struct wxWeakRefImpl<T, true> : public wxWeakRefStatic<T>
 107 {
 108     enum { value = 1 };
 109 };
 110
 111 // Weak ref implementation when T does not have wxTrackable as known base class
 112 template<class T>
 113 struct wxWeakRefImpl<T, false> : public wxTrackerNode
 114 {
 115     void Release()
 116     {
 117         // Release old object if any
 118         if ( m_pobj )
 119         {
 120             // Remove ourselves from object tracker list
 121             m_ptbase->RemoveNode(this);
 122             m_pobj = NULL;
 123             m_ptbase = NULL;
 124         }
 125     }
 126
 127     virtual void OnObjectDestroy()
 128     {
 129         // Tracked object itself removes us from list of trackers
 130         wxASSERT(m_pobj != NULL);
 131         m_pobj = NULL;
 132         m_ptbase = NULL;
 133     }
 134
 135 protected:
 136     wxWeakRefImpl() : m_pobj(NULL), m_ptbase(NULL) { }
 137
 138     // Assign receives most derived class here and can use that
 139     template <class TDerived>
 140     void Assign( TDerived* pobj )
 141     {
 142         AssignHelper( pobj, wxInt2Type<wxIsStaticTrackable<TDerived>::value>() );
 143     }
 144
 145     template <class TDerived>
 146     void AssignHelper(TDerived* pobj, wxInt2Type<true>)
 147     {
 148         wxTrackable *ptbase = static_cast<wxTrackable*>(pobj);
 149         DoAssign( pobj, ptbase );
 150     }
 151
 152 #ifndef wxNO_RTTI
 153     void AssignHelper(T* pobj, wxInt2Type<false>)
 154     {
 155         // A last way to get a trackable pointer
 156         wxTrackable *ptbase = dynamic_cast<wxTrackable*>(pobj);
 157         if ( ptbase )
 158         {
 159             DoAssign( pobj, ptbase );
 160         }
 161         else
 162         {
 163             wxFAIL_MSG( "Tracked class should inherit from wxTrackable" );
 164
 165             Release();
 166         }
 167     }
 168 #endif // RTTI enabled
 169
 170     void AssignCopy(const wxWeakRefImpl& wr)
 171     {
 172         DoAssign(wr.m_pobj, wr.m_ptbase);
 173     }
 174
 175     void DoAssign( T* pobj, wxTrackable *ptbase ) {
 176         if( m_pobj==pobj ) return;
 177         Release();
 178
 179         // Now set new trackable object
 180         if( pobj )
 181         {
 182             // Add ourselves to object tracker list
 183             wxASSERT( ptbase );
 184             ptbase->AddNode( this );
 185             m_pobj = pobj;
 186             m_ptbase = ptbase;
 187         }
 188     }
 189
 190     T *m_pobj;
 191     wxTrackable *m_ptbase;
 192 };
 193
 194 #endif // #ifndef USE_ONLY_STATIC_WEAKREF
 195
 196
 197
 198 // A weak reference to an object of type T, where T has base wxTrackable
 199 // (usually statically but if not dynamic_cast<> is tried).
 200 template <class T>
 201 class wxWeakRef : public
 202 #ifdef USE_ONLY_STATIC_WEAKREF
 203                   wxWeakRefStatic<T>
 204 #else
 205                   wxWeakRefImpl<T, wxIsStaticTrackable<T>::value != 0>
 206 #endif
 207 {
 208 public:
 209     typedef T element_type;
 210
 211     // Default ctor
 212     wxWeakRef() { }
 213
 214     // Enabling this ctor for VC6 results in mysterious compilation failures in
 215     // wx/window.h when assigning wxWindow pointers (FIXME-VC6)
 216 #ifndef __VISUALC6__
 217     // Ctor from the object of this type: this is needed as the template ctor
 218     // below is not used by at least g++4 when a literal NULL is used
 219     wxWeakRef(T *pobj)
 220     {
 221         Assign(pobj);
 222     }
 223 #endif // !__VISUALC6__
 224
 225     // When we have the full type here, static_cast<> will always work
 226     // (or give a straight compiler error).
 227     template <class TDerived>
 228     wxWeakRef(TDerived* pobj)
 229     {
 230         Assign(pobj);
 231     }
 232
 233     // We need this copy ctor, since otherwise a default compiler (binary) copy
 234     // happens (if embedded as an object member).
 235     wxWeakRef(const wxWeakRef<T>& wr)
 236     {
 237         Assign(wr.get());
 238     }
 239
 240     wxWeakRef<T>& operator=(const wxWeakRef<T>& wr)
 241     {
 242         AssignCopy(wr);
 243         return *this;
 244     }
 245
 246     virtual ~wxWeakRef() { this->Release(); }
 247
 248     // Smart pointer functions
 249     T& operator*() const    { return *this->m_pobj; }
 250     T* operator->() const   { return this->m_pobj; }
 251
 252     T* get() const          { return this->m_pobj; }
 253     operator T*() const     { return this->m_pobj; }
 254 };
 255
 256
 257 #ifndef wxNO_RTTI
 258
 259 // Weak ref implementation assign objects are queried for wxTrackable
 260 // using dynamic_cast<>
 261 template <class T>
 262 class wxWeakRefDynamic : public wxTrackerNode
 263 {
 264 public:
 265     wxWeakRefDynamic() : m_pobj(NULL) { }
 266
 267     wxWeakRefDynamic(T* pobj) : m_pobj(pobj)
 268     {
 269         Assign(pobj);
 270     }
 271
 272     wxWeakRefDynamic(const wxWeakRef<T>& wr)
 273     {
 274         Assign(wr.get());
 275     }
 276
 277     virtual ~wxWeakRefDynamic() { Release(); }
 278
 279     // Smart pointer functions
 280     T& operator*() const    { wxASSERT(m_pobj); return *m_pobj; }
 281     T* operator->() const   { wxASSERT(m_pobj); return m_pobj; }
 282
 283     T* get() const          { return m_pobj; }
 284     operator T* () const    { return m_pobj; }
 285
 286     T* operator = (T* pobj) { Assign(pobj); return m_pobj; }
 287
 288     // Assign from another weak ref, point to same object
 289     T* operator = (const wxWeakRef<T> &wr) { Assign( wr.get() ); return m_pobj; }
 290
 291     void Release()
 292     {
 293         // Release old object if any
 294         if( m_pobj )
 295         {
 296             // Remove ourselves from object tracker list
 297             wxTrackable *pt = dynamic_cast<wxTrackable*>(m_pobj);
 298             wxASSERT(pt);
 299             pt->RemoveNode(this);
 300             m_pobj = NULL;
 301         }
 302     }
 303
 304     virtual void OnObjectDestroy()
 305     {
 306         wxASSERT_MSG(m_pobj, "tracked object should have removed us itself");
 307
 308         m_pobj = NULL;
 309     }
 310
 311 protected:
 312     void Assign(T *pobj)
 313     {
 314         if ( m_pobj == pobj )
 315             return;
 316
 317         Release();
 318
 319         // Now set new trackable object
 320         if ( pobj )
 321         {
 322             // Add ourselves to object tracker list
 323             wxTrackable *pt = dynamic_cast<wxTrackable*>(pobj);
 324             if ( pt )
 325             {
 326                 pt->AddNode(this);
 327                 m_pobj = pobj;
 328             }
 329             else
 330             {
 331                 // If the object we want to track does not support wxTackable, then
 332                 // log a message and keep the NULL object pointer.
 333                 wxFAIL_MSG( "Tracked class should inherit from wxTrackable" );
 334             }
 335         }
 336     }
 337
 338     T *m_pobj;
 339 };
 340
 341 #endif // RTTI enabled
 342
 343
 344 // Provide some basic types of weak references
 345 class WXDLLIMPEXP_FWD_BASE wxEvtHandler;
 346 class WXDLLIMPEXP_FWD_CORE wxWindow;
 347
 348
 349 typedef wxWeakRef<wxEvtHandler>  wxEvtHandlerRef;
 350 typedef wxWeakRef<wxWindow>      wxWindowRef;
 351
 352 #endif // _WX_WEAKREF_H_
 353