GME  13
OCLRefCount.h
Go to the documentation of this file.
00001 //###############################################################################################################################################
00002 //
00003 //      Object Constraint Language Generic Manager
00004 //      OCLRefCount.h
00005 //
00006 //###############################################################################################################################################
00007 
00008 #ifndef OCLRefCount_h
00009 #define OCLRefCount_h
00010 
00011 namespace OclCommon
00012 {
00013         template < class TRefCount >    class ReferenceCountable;
00014         template < class TRefCount >    class RCSmart;
00015         template < class TObject >              class Smart;
00016 
00017 //###############################################################################################################################################
00018 //
00019 //      T E M P L A T E   C L A S S : ReferenceCountable
00020 //
00021 //==============================================================================================================================================
00022 //
00023 //      D E S C R I P T I O N :
00024 //
00025 //##############################################################################################################################################
00026 
00027         template < class TRefCount >
00028         class ReferenceCountable
00029         {
00030                 private :
00031                         int     m_iRefCount;
00032 
00033                 protected :
00034                         ReferenceCountable()
00035                                 : m_iRefCount( 0 )
00036                         {
00037                         }
00038 
00039                 public :
00040                         virtual ~ReferenceCountable()
00041                         {
00042                         }
00043 
00044                 friend class RCSmart< TRefCount >;
00045         };
00046 
00047 //###############################################################################################################################################
00048 //
00049 //      T E M P L A T E   C L A S S : RCSmart
00050 //
00051 //==============================================================================================================================================
00052 //
00053 //      D E S C R I P T I O N :
00054 //
00055 //##############################################################################################################################################
00056 
00057         template < class TRefCount >
00058         class RCSmart
00059         {
00060                 private :
00061                         TRefCount* m_p;
00062 
00063                 public :
00064                         RCSmart()
00065                                 : m_p( 0 )
00066                         {
00067                         }
00068 
00069                         RCSmart( TRefCount* q )
00070                                 : m_p( q )
00071                         {
00072                                 IncRef();
00073                         }
00074 
00075                         RCSmart( const RCSmart<TRefCount>& q )
00076                                 : m_p( q.m_p )
00077                         {
00078                                 IncRef();
00079                         }
00080 
00081                         virtual ~RCSmart()
00082                         {
00083                                 DecRef();
00084                         }
00085 
00086                         RCSmart<TRefCount>& operator=( const RCSmart<TRefCount>& q )
00087                         {
00088                                 if ( *this != q ) {
00089                                         DecRef();
00090                                         m_p = q.m_p;
00091                                         IncRef();
00092                                 }
00093                                 return *this;
00094                         }
00095 
00096                         RCSmart<TRefCount>& operator=( TRefCount* q )
00097                         {
00098                                 if ( m_p != q ) {
00099                                         DecRef();
00100                                         m_p = q;
00101                                         IncRef();
00102                                 }
00103                                 return *this;
00104                         }
00105 
00106                         bool operator==( const RCSmart<TRefCount>& q ) const
00107                         {
00108                                 return m_p == q.m_p;
00109                         }
00110 
00111                         bool operator!=( const RCSmart<TRefCount>& q ) const
00112                         {
00113                                 return ! ( *this == q );
00114                         }
00115 
00116                         operator TRefCount*() const
00117                         {
00118                                 return m_p;
00119                         }
00120 
00121                         TRefCount& operator *() const
00122                         {
00123                                 return *m_p;
00124                         }
00125 
00126                         TRefCount* operator->() const
00127                         {
00128                                 return m_p;
00129                         }
00130 
00131 
00132                         TRefCount* Ptr() const
00133                         {
00134                                 return m_p;
00135                         }
00136 
00137                         bool IsNull() const
00138                         {
00139                                 return m_p == 0;
00140                         }
00141 
00142                 private :
00143                         void IncRef()
00144                         {
00145                                 if  ( m_p )
00146                                         m_p->m_iRefCount++;
00147                         }
00148 
00149                         void DecRef()
00150                         {
00151                                 if ( m_p )
00152                                         if ( --m_p->m_iRefCount == 0 ) {
00153                                                 delete m_p;
00154                                                 m_p = 0;
00155                                         }
00156                         }
00157         };
00158 
00159 //###############################################################################################################################################
00160 //
00161 //      T E M P L A T E   C L A S S : Smart
00162 //
00163 //==============================================================================================================================================
00164 //
00165 //      D E S C R I P T I O N :
00166 //
00167 //##############################################################################################################################################
00168 
00169         template < class TObject >
00170         class Smart
00171         {
00172                 private :
00173                         TObject*        m_p;
00174 
00175                 public :
00176                         Smart()
00177                                 : m_p( 0 )
00178                         {
00179                         }
00180 
00181                         Smart( TObject* q )
00182                                 : m_p( q )
00183                         {
00184                         }
00185 
00186                         ~Smart()
00187                         {
00188                                 if ( m_p )
00189                                         delete m_p;
00190                         }
00191 
00192                         bool operator==( const Smart<TObject>& q ) const
00193                         {
00194                                 return m_p == q.m_p;
00195                         }
00196 
00197                         bool operator!=( const Smart<TObject>& q ) const
00198                         {
00199                                 return ! ( *this == q );
00200                         }
00201 
00202                         bool operator==( const TObject* const q ) const
00203                         {
00204                                 return m_p == q;
00205                         }
00206 
00207                         bool operator!=( const TObject* const q ) const
00208                         {
00209                                 return ! ( *this == q );
00210                         }
00211 
00212                         operator TObject*() const
00213                         {
00214                                 return m_p;
00215                         }
00216 
00217                         TObject& operator *() const
00218                         {
00219                                 return *m_p;
00220                         }
00221 
00222                         TObject* operator ->() const
00223                         {
00224                                 return m_p;
00225                         }
00226 
00227                         TObject* Ptr() const
00228                         {
00229                                 return m_p;
00230                         }
00231 
00232                         bool IsNull() const
00233                         {
00234                                 return m_p == 0;
00235                         }
00236         };
00237 
00238 }; // namespace OclCommon
00239 
00240 #endif // OCLRefCount_h