llpointer.h
上传用户:king477883
上传日期:2021-03-01
资源大小:9553k
文件大小:5k
源码类别:

游戏引擎

开发平台:

C++ Builder

  1. /** 
  2.  * @file llpointer.h
  3.  * @brief A reference-counted pointer for objects derived from LLRefCount
  4.  *
  5.  * $LicenseInfo:firstyear=2002&license=viewergpl$
  6.  * 
  7.  * Copyright (c) 2002-2010, Linden Research, Inc.
  8.  * 
  9.  * Second Life Viewer Source Code
  10.  * The source code in this file ("Source Code") is provided by Linden Lab
  11.  * to you under the terms of the GNU General Public License, version 2.0
  12.  * ("GPL"), unless you have obtained a separate licensing agreement
  13.  * ("Other License"), formally executed by you and Linden Lab.  Terms of
  14.  * the GPL can be found in doc/GPL-license.txt in this distribution, or
  15.  * online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
  16.  * 
  17.  * There are special exceptions to the terms and conditions of the GPL as
  18.  * it is applied to this Source Code. View the full text of the exception
  19.  * in the file doc/FLOSS-exception.txt in this software distribution, or
  20.  * online at
  21.  * http://secondlifegrid.net/programs/open_source/licensing/flossexception
  22.  * 
  23.  * By copying, modifying or distributing this software, you acknowledge
  24.  * that you have read and understood your obligations described above,
  25.  * and agree to abide by those obligations.
  26.  * 
  27.  * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
  28.  * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
  29.  * COMPLETENESS OR PERFORMANCE.
  30.  * $/LicenseInfo$
  31.  */
  32. #ifndef LLPOINTER_H
  33. #define LLPOINTER_H
  34. #include "llerror.h" // *TODO: consider eliminating this
  35. //----------------------------------------------------------------------------
  36. // RefCount objects should generally only be accessed by way of LLPointer<>'s
  37. // NOTE: LLPointer<LLFoo> x = new LLFoo(); MAY NOT BE THREAD SAFE
  38. //   if LLFoo::LLFoo() does anything like put itself in an update queue.
  39. //   The queue may get accessed before it gets assigned to x.
  40. // The correct implementation is:
  41. //   LLPointer<LLFoo> x = new LLFoo; // constructor does not do anything interesting
  42. //   x->instantiate(); // does stuff like place x into an update queue
  43. // see llthread.h for LLThreadSafeRefCount
  44. //----------------------------------------------------------------------------
  45. // Note: relies on Type having ref() and unref() methods
  46. template <class Type> class LLPointer
  47. {
  48. public:
  49. LLPointer() : 
  50. mPointer(NULL)
  51. {
  52. }
  53. LLPointer(Type* ptr) : 
  54. mPointer(ptr)
  55. {
  56. ref();
  57. }
  58. LLPointer(const LLPointer<Type>& ptr) : 
  59. mPointer(ptr.mPointer)
  60. {
  61. ref();
  62. }
  63. // support conversion up the type hierarchy.  See Item 45 in Effective C++, 3rd Ed.
  64. template<typename Subclass>
  65. LLPointer(const LLPointer<Subclass>& ptr) : 
  66. mPointer(ptr.get())
  67. {
  68. ref();
  69. }
  70. ~LLPointer()
  71. {
  72. unref();
  73. }
  74. Type* get() const { return mPointer; }
  75. const Type* operator->() const { return mPointer; }
  76. Type* operator->() { return mPointer; }
  77. const Type& operator*() const { return *mPointer; }
  78. Type& operator*() { return *mPointer; }
  79. operator BOOL()  const { return (mPointer != NULL); }
  80. operator bool()  const { return (mPointer != NULL); }
  81. bool operator!() const { return (mPointer == NULL); }
  82. bool isNull() const { return (mPointer == NULL); }
  83. bool notNull() const { return (mPointer != NULL); }
  84. operator Type*()       const { return mPointer; }
  85. bool operator !=(Type* ptr) const           { return (mPointer != ptr);  }
  86. bool operator ==(Type* ptr) const           { return (mPointer == ptr);  }
  87. bool operator ==(const LLPointer<Type>& ptr) const           { return (mPointer == ptr.mPointer);  }
  88. bool operator < (const LLPointer<Type>& ptr) const           { return (mPointer < ptr.mPointer);  }
  89. bool operator > (const LLPointer<Type>& ptr) const           { return (mPointer > ptr.mPointer);  }
  90. LLPointer<Type>& operator =(Type* ptr)                   
  91. if( mPointer != ptr )
  92. {
  93. unref(); 
  94. mPointer = ptr; 
  95. ref();
  96. }
  97. return *this; 
  98. }
  99. LLPointer<Type>& operator =(const LLPointer<Type>& ptr)  
  100. if( mPointer != ptr.mPointer )
  101. {
  102. unref(); 
  103. mPointer = ptr.mPointer;
  104. ref();
  105. }
  106. return *this; 
  107. }
  108. // support assignment up the type hierarchy. See Item 45 in Effective C++, 3rd Ed.
  109. template<typename Subclass>
  110. LLPointer<Type>& operator =(const LLPointer<Subclass>& ptr)  
  111. if( mPointer != ptr.get() )
  112. {
  113. unref(); 
  114. mPointer = ptr.get();
  115. ref();
  116. }
  117. return *this; 
  118. }
  119. // Just exchange the pointers, which will not change the reference counts.
  120. static void swap(LLPointer<Type>& a, LLPointer<Type>& b)
  121. {
  122. Type* temp = a.mPointer;
  123. a.mPointer = b.mPointer;
  124. b.mPointer = temp;
  125. }
  126. protected:
  127. void ref()                             
  128. if (mPointer)
  129. {
  130. mPointer->ref();
  131. }
  132. }
  133. void unref()
  134. {
  135. if (mPointer)
  136. {
  137. Type *tempp = mPointer;
  138. mPointer = NULL;
  139. tempp->unref();
  140. if (mPointer != NULL)
  141. {
  142. llwarns << "Unreference did assignment to non-NULL because of destructor" << llendl;
  143. unref();
  144. }
  145. }
  146. }
  147. protected:
  148. Type* mPointer;
  149. };
  150. #endif