src/SUIT/SUIT_SmartPtr.h

   1 // Copyright (C) 2007-2022  CEA/DEN, EDF R&D, OPEN CASCADE
   2 //
   3 // Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
   4 // CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
   5 //
   6 // This library is free software; you can redistribute it and/or
   7 // modify it under the terms of the GNU Lesser General Public
   8 // License as published by the Free Software Foundation; either
   9 // version 2.1 of the License, or (at your option) any later version.
  10 //
  11 // This library is distributed in the hope that it will be useful,
  12 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14 // Lesser General Public License for more details.
  15 //
  16 // You should have received a copy of the GNU Lesser General Public
  17 // License along with this library; if not, write to the Free Software
  18 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  19 //
  20 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
  21 //
  22
  23 #if !defined(__SUIT_SMARTPTR_H)
  24 #define __SUIT_SMARTPTR_H
  25
  26 #include "SUIT.h"
  27
  28 /*! \brief Base counter class what children using in SmartPtr class how template */
  29 class SUIT_EXPORT RefCount {
  30 public:
  31   //! constructor
  32   RefCount() : crefs( 0 ) {}
  33   //! copy constructor
  34   RefCount( const RefCount& ) : crefs( 0 ) {}
  35   //! destructor
  36   virtual ~RefCount() {}
  37   //! operator= (does not change counter)
  38   RefCount& operator=( const RefCount& ) { return *this; }
  39
  40   //! increments reference counter
  41   void upcount() {
  42     ++crefs;
  43   }
  44
  45   //! decrements reference counter
  46   void downcount()
  47   {
  48     if ( crefs > 0 && --crefs == 0 )
  49       delete this;
  50   }
  51
  52   //! get reference counter value
  53   int refcount() const { return crefs; }
  54
  55 private:
  56   unsigned long crefs;   //!< reference counter
  57 };
  58
  59 /*! \brief Template class that provides automatic casting for hold RefCount based objects.*/
  60 template <class T> class SmartPtr {
  61 public:
  62   //! default constructor
  63   SmartPtr() : p( 0 ) {}
  64   //! constructor from any RefCount-based class
  65   template<class Y> SmartPtr( Y* y_ ) { p = dynamic_cast<T*>( y_ ); if ( p ) p->upcount(); }
  66   //! copy constructor from any RefCount-based class
  67   template<class Y> SmartPtr( const SmartPtr<Y>& y_ ) { p = dynamic_cast<T*>( y_.get() ); if ( p ) p->upcount(); }
  68   //! copy constructor
  69   SmartPtr( const SmartPtr& t_ ) : p( t_.p ) { if ( p ) p->upcount();   }
  70   //! destructor
  71   virtual ~SmartPtr(void)
  72   {
  73     if ( p )
  74       p->downcount();
  75   }
  76
  77   // getting access
  78   T& operator*() const        { return *p;           }//!< return *pointer
  79   T* operator->() const       { return  p;           }//!< return pointer
  80   operator T*() const         { return  p;           }//!< return pointer
  81   T* get() const              { return  p;           }//!< return pointer
  82
  83   //! assignment
  84   template<class Y> SmartPtr& operator=( const SmartPtr<Y>& y_ )
  85   {
  86     if ( this == &y_) return *this;
  87     return operator=( y_.get() );
  88   }
  89   //! assignment
  90   SmartPtr& operator=( const SmartPtr& t_ )
  91   {
  92     if ( this == &t_) return *this;
  93     return operator=( t_.get() );
  94   }
  95   //!< assignment
  96   SmartPtr& operator=( T* p_ )
  97   {
  98     if ( p )
  99       p->downcount();
 100     p = p_;
 101     if ( p )
 102       p->upcount();
 103     return *this;
 104   }
 105
 106   // comparing
 107   int operator==( const SmartPtr& t_ ) { return p == t_.p; }//!< comparing
 108   int operator==( const T* p_ )           { return p == p_; }//!< comparing
 109   friend int operator==( const T* p_, const SmartPtr& t_ ) { return t_ == p_; }//!< comparing
 110   int operator!=( SmartPtr& t_ ) { return p != t_.p; }//!< comparing
 111   int operator!=( T* p_ )           { return p != p_; }//!< comparing
 112   friend int operator!=( T* p_, SmartPtr& t_ ) { return p_ != t_.p; }//!< comparing
 113
 114   //! nullify
 115   void nullify() { if ( p ) p->downcount(); p = 0; }
 116   //! check for null
 117   bool isNull() const { return p == 0; }
 118
 119 private:
 120   T* p;//!< stored pointer
 121 };
 122
 123 /*! \def SMART( C )
 124  * Define macros SMART( C ) - same as SmartPtr(C), where \a C - class object.
 125  */
 126 #define SMART( C ) SmartPtr<C>
 127 //! casting class T2 to class T1
 128 template <class T1, class T2> SMART(T1) downcast( SMART(T2)& t )
 129 {
 130   return SMART(T1)(t.get());
 131 }
 132
 133 #endif // __SUIT_SMARTPTR_H