include/core/weakpointer.h

   1 #ifndef AWFUL_WEAKPOINTER_H_
   2 #define AWFUL_WEAKPOINTER_H_
   3
   4 // TODO: make this shit work
   5
   6 namespace awful
   7 {
   8         template< class C > class Pointer;
   9         template< class C > class ConstPointer;
  10
  11         template< class C > class weakptrproxy
  12         {
  13                 public:
  14                         weakptrproxy( const C* pObj_ ) :
  15                                 m_WeakRefCount( 1 ),
  16                                 m_pObj( const_cast< C* >( pObj_ ) )
  17                         {
  18                         }
  19
  20                         ~weakptrproxy()
  21                         {
  22                                 if( m_pObj )
  23                                         m_pObj->m_pWeakPtrProxy = 0;
  24                         }
  25
  26                 private:
  27                         unsigned long   m_WeakRefCount;
  28                         C*                              m_pObj;
  29         };
  30
  31         template< class C, typename P > class weakptr
  32         {
  33                 template< class C_, class P_ > friend class ptr;
  34
  35                 public:
  36                         weakptr() :
  37                                 m_pProxy( 0 )
  38                         {
  39                         }
  40
  41                         weakptr& operator=( const weakptr& wptr_ )
  42                         {
  43                                 if( m_pProxy == wptr_.m_pProxy )
  44                                         return *this;
  45
  46                                 if( m_pProxy )
  47                                         m_pProxy->remRef();
  48
  49                                 m_pProxy = wptr_.m_pProxy;
  50                                 m_pProxy->addRef();
  51                         }
  52
  53                 protected:
  54                         weakptr( P pObj_ )
  55                         {
  56                                 if( !pObj_ )
  57                                 {
  58                                         m_pProxy = 0;
  59                                         return;
  60                                 }
  61
  62                                 setObj( pObj_ );
  63                         }
  64
  65                         weakptr& operator=( P pObj_ )
  66                         {
  67                                 if( m_pProxy == pObj_.m_pProxy )
  68                                         return *this;
  69
  70                                 if( m_pProxy )
  71                                         m_pProxy->remRef();
  72
  73                                 setObj( pObj_ );
  74                         }
  75
  76                 private:
  77                         void incRef() const
  78                         {
  79                                 if( m_pProxy )
  80                                         ++m_pProxy->m_WeakRefCount;
  81                         }
  82
  83                         void decRef()
  84                         {
  85                                 if( !m_pProxy )
  86                                         return;
  87
  88                                 if( !( --m_pProxy->m_WeakRefCount ) )
  89                                 {
  90                                         delete m_pProxy;
  91                                         m_pProxy = 0;
  92                                 }
  93                         }
  94
  95                         void setObj( P pObj_ )
  96                         {
  97                                 if( pObj_->m_pWeakPtrProxy )
  98                                 {
  99                                         m_pProxy = pObj_->m_pWeakPtrProxy;
 100                                         incRef();
 101                                 }
 102                                 else
 103                                 {
 104                                         m_pProxy = pObj_->m_pWeakPtrProxy = new weakptrproxy< C >( pObj_ );
 105                                 }
 106                         }
 107
 108                         operator P() const
 109                         {
 110                                 if( m_pProxy && !m_pProxy->m_pObj )
 111                                 {
 112                                         decRef();
 113                                         m_pProxy = 0;
 114                                 }
 115
 116                                 if( !m_pProxy )
 117                                         return 0;
 118
 119                                 return m_pProxy->m_pObj;
 120                         }
 121
 122                         mutable weakptrproxy< C >*      m_pProxy;
 123         };
 124
 125         template< class C > class WeakPointer : public weakptr< C, C* >
 126         {
 127                 public:
 128                         WeakPointer() :
 129                                 weakptr< C, C* >()
 130                         {
 131                         }
 132
 133                         WeakPointer( const WeakPointer& Ptr_ ) :
 134                                 weakptr< C, C* >( Ptr_ )
 135                         {
 136                         }
 137
 138                         WeakPointer( const Pointer< C >& Ptr_ ) :
 139                                 weakptr< C, C* >( Ptr_ )
 140                         {
 141                         }
 142         };
 143
 144         template< class C > class WeakConstPointer : public weakptr< C, const C* >
 145         {
 146                 public:
 147                         WeakConstPointer() :
 148                                 weakptr< C, const C* >()
 149                         {
 150                         }
 151
 152                         WeakConstPointer( const WeakConstPointer& Ptr_ ) :
 153                                 weakptr< C, const C* >( Ptr_ )
 154                         {
 155                         }
 156
 157                         WeakConstPointer( const WeakPointer< C >& Ptr_ ) :
 158                                 weakptr< C, const C* >( Ptr_ )
 159                         {
 160                         }
 161
 162                         WeakConstPointer( const ConstPointer< C >& Ptr_ ) :
 163                                 weakptr< C, const C* >( Ptr_ )
 164                         {
 165                         }
 166
 167                         WeakConstPointer( const Pointer< C >& Ptr_ ) :
 168                                 weakptr< C, const C* >( Ptr_ )
 169                         {
 170                         }
 171         };
 172 }
 173
 174 #endif