1 // Copyright (C) 2007-2014 CEA/DEN, EDF R&D, OPEN CASCADE
3 // Copyright (C) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
4 // CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
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.
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.
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
20 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
23 #if !defined(__SUIT_SMARTPTR_H)
24 #define __SUIT_SMARTPTR_H
28 /*! \brief Base counter class what children using in SmartPtr class how template */
29 class SUIT_EXPORT RefCount {
32 RefCount() : crefs( 0 ) {}
34 RefCount( const RefCount& ) : crefs( 0 ) {}
36 virtual ~RefCount() {}
37 //! operator= (does not change counter)
38 RefCount& operator=( const RefCount& ) { return *this; }
40 //! increments reference counter
45 //! decrements reference counter
48 if ( crefs > 0 && --crefs == 0 )
52 //! get reference counter value
53 int refcount() const { return crefs; }
56 unsigned long crefs; //!< reference counter
59 /*! \brief Template class that provides automatic casting for hold RefCount based objects.*/
60 template <class T> class SmartPtr {
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(); }
69 SmartPtr( const SmartPtr& t_ ) : p( t_.p ) { if ( p ) p->upcount(); }
71 virtual ~SmartPtr(void)
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
84 template<class Y> SmartPtr& operator=( const SmartPtr<Y>& y_ )
86 if ( this == &y_) return *this;
87 return operator=( y_.get() );
90 SmartPtr& operator=( const SmartPtr& t_ )
92 if ( this == &t_) return *this;
93 return operator=( t_.get() );
96 SmartPtr& operator=( T* p_ )
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
115 void nullify() { if ( p ) p->downcount(); p = 0; }
117 bool isNull() const { return p == 0; }
120 T* p;//!< stored pointer
124 * Define macros SMART( C ) - same as SmartPtr(C), where \a C - class object.
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 )
130 return SMART(T1)(t.get());
133 #endif // __SUIT_SMARTPTR_H