home *** CD-ROM | disk | FTP | other *** search
/ Clickx 115 / Clickx 115.iso / software / tools / windows / tails-i386-0.16.iso / live / filesystem.squashfs / usr / include / scribus-ng / scguardedptr.h < prev    next >
Encoding:
C/C++ Source or Header  |  2007-09-09  |  3.2 KB  |  152 lines
  1. /*
  2. For general Scribus (>=1.3.2) copyright and licensing information please refer
  3. to the COPYING file provided with the program. Following this notice may exist
  4. a copyright and/or license notice that predates the release of Scribus 1.3.2
  5. for which a new license (GPL+exception) is in place.
  6. */
  7. #ifndef SCGUARDEDPTR_H
  8. #define SCGUARDEDPTR_H
  9.  
  10. #include "scribusapi.h"
  11. #include "assert.h"
  12. /*
  13. A replacement for QPointer
  14. Does not rely on QObject, and provides faster destructor
  15. */ 
  16.  
  17. template<typename T>
  18. class ScGuardedPtrData
  19. {
  20. public:
  21.  
  22.     int refs;
  23.     T* pointer;
  24.  
  25.     ScGuardedPtrData(void) { pointer = NULL; refs = 0; }
  26.     ScGuardedPtrData(T* ptr) { pointer = ptr; refs = 0; }
  27. };
  28.  
  29. template<typename T>
  30. class ScGuardedPtr
  31. {
  32. protected:
  33.     ScGuardedPtrData<T> *data;
  34. public:
  35.     ScGuardedPtr(void);
  36.     ScGuardedPtr(T* ptr);
  37.     ScGuardedPtr(const ScGuardedPtr& gPtr);
  38.     ~ScGuardedPtr();
  39.  
  40.     ScGuardedPtr& operator=(const ScGuardedPtr& gPtr);
  41.     bool operator==( const ScGuardedPtr<T> &p ) const { return (T*)(*this) == (T*) p;}
  42.     bool operator!= ( const ScGuardedPtr<T>& p ) const { return !( *this == p ); }
  43.  
  44.     T* operator->() const { return (T*)(data ? data->pointer : 0); }
  45.     T& operator*() const { return *((T*)(data ? data->pointer : 0)); }
  46.     operator T*() const { return (T*)(data ? data->pointer : 0); }
  47.  
  48.     void deref(void);
  49. };
  50.  
  51. template<typename T>
  52. class ScGuardedObject : public ScGuardedPtr<T>
  53. {
  54. public:
  55.     ScGuardedObject(T* ptr);
  56.     ScGuardedObject(const ScGuardedObject& gPtr);
  57.     ~ScGuardedObject();
  58.  
  59.     ScGuardedObject& operator=(const ScGuardedObject& gPtr);
  60.     bool operator==( const ScGuardedObject<T> &p ) const { return (T*)(*this) == (T*) p;}
  61.     bool operator!= ( const ScGuardedObject<T>& p ) const { return !( *this == p ); }
  62.  
  63.     void nullify(void);
  64. };
  65.  
  66. template<typename T>
  67. ScGuardedPtr<T>::ScGuardedPtr(void)
  68. {
  69.     data = new ScGuardedPtrData<T>();
  70.     ++(data->refs);
  71. };
  72.  
  73. template<typename T>
  74. ScGuardedPtr<T>::ScGuardedPtr(T* ptr)
  75. {
  76.     data = new ScGuardedPtrData<T>(ptr);
  77.     ++(data->refs);
  78. };
  79.  
  80. template<typename T>
  81. ScGuardedPtr<T>::ScGuardedPtr(const ScGuardedPtr& other)
  82. {
  83.     data = other.data;
  84.     ++(data->refs);
  85. };
  86.  
  87. template<typename T>
  88. ScGuardedPtr<T>::~ScGuardedPtr()
  89. {
  90.     deref();
  91. };
  92.  
  93. template<typename T>
  94. ScGuardedPtr<T>& ScGuardedPtr<T>::operator=(const ScGuardedPtr& other)
  95. {
  96.     // We do not copy the owner member
  97.     if (data != other.data)
  98.     {
  99.         ++(other.data->refs);
  100.         deref();
  101.         data = other.data;
  102.     }
  103.     return *this;
  104. };
  105.  
  106. template<typename T>
  107. void ScGuardedPtr<T>::deref(void)
  108. {
  109.     if (data && --(data->refs) == 0)
  110.     {
  111.         delete data;
  112.         data = NULL;
  113.     }
  114. };
  115.  
  116. template<typename T>
  117. ScGuardedObject<T>::ScGuardedObject(T* ptr) : ScGuardedPtr<T>(ptr)
  118. {
  119. };
  120.  
  121. template<typename T>
  122. ScGuardedObject<T>::ScGuardedObject(const ScGuardedObject& other)
  123. {
  124.     this->data=NULL;
  125.     // Must never be used
  126.     assert(false);
  127. };
  128.  
  129. template<typename T>
  130. ScGuardedObject<T>& ScGuardedObject<T>::operator=(const ScGuardedObject& other)
  131. {
  132.     // We do nothing, think about an object being assigned to another
  133.     // The object being assigned must keep track of its own data
  134.     return *this;
  135. };
  136.  
  137. template<typename T>
  138. void ScGuardedObject<T>::nullify(void)
  139. {
  140.     if (this->data)
  141.         this->data->pointer = NULL;
  142. };
  143.  
  144. template<typename T>
  145. ScGuardedObject<T>::~ScGuardedObject()
  146. {
  147.     nullify();
  148.     // deref() is called by ScGuardedPtr<T> dtor
  149. };
  150.  
  151. #endif
  152.