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

游戏引擎

开发平台:

C++ Builder

  1. /** 
  2.  * @file llsafehandle.h
  3.  * @brief Reference-counted object where Object() is valid, not NULL.
  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 LLSAFEHANDLE_H
  33. #define LLSAFEHANDLE_H
  34. #include "llerror.h" // *TODO: consider eliminating this
  35. // Expands LLPointer to return a pointer to a special instance of class Type instead of NULL.
  36. // This is useful in instances where operations on NULL pointers are semantically safe and/or
  37. // when error checking occurs at a different granularity or in a different part of the code
  38. // than when referencing an object via a LLSafeHandle.
  39. template <class Type> 
  40. class LLSafeHandle
  41. {
  42. public:
  43. LLSafeHandle() :
  44. mPointer(NULL)
  45. {
  46. }
  47. LLSafeHandle(Type* ptr) : 
  48. mPointer(NULL)
  49. {
  50. assign(ptr);
  51. }
  52. LLSafeHandle(const LLSafeHandle<Type>& ptr) : 
  53. mPointer(NULL)
  54. {
  55. assign(ptr.mPointer);
  56. }
  57. // support conversion up the type hierarchy.  See Item 45 in Effective C++, 3rd Ed.
  58. template<typename Subclass>
  59. LLSafeHandle(const LLSafeHandle<Subclass>& ptr) : 
  60. mPointer(NULL)
  61. {
  62. assign(ptr.get());
  63. }
  64. ~LLSafeHandle()
  65. {
  66. unref();
  67. }
  68. const Type* operator->() const { return nonNull(mPointer); }
  69. Type* operator->() { return nonNull(mPointer); }
  70. Type* get() const { return mPointer; }
  71. void clear() { assign(NULL); }
  72. // we disallow these operations as they expose our null objects to direct manipulation
  73. // and bypass the reference counting semantics
  74. //const Type& operator*() const { return *nonNull(mPointer); }
  75. //Type& operator*() { return *nonNull(mPointer); }
  76. operator BOOL()  const { return mPointer != NULL; }
  77. operator bool()  const { return mPointer != NULL; }
  78. bool operator!() const { return mPointer == NULL; }
  79. bool isNull() const { return mPointer == NULL; }
  80. bool notNull() const { return mPointer != NULL; }
  81. operator Type*()       const { return mPointer; }
  82. operator const Type*() const { return mPointer; }
  83. bool operator !=(Type* ptr) const           { return (mPointer != ptr);  }
  84. bool operator ==(Type* ptr) const           { return (mPointer == ptr);  }
  85. bool operator ==(const LLSafeHandle<Type>& ptr) const           { return (mPointer == ptr.mPointer);  }
  86. bool operator < (const LLSafeHandle<Type>& ptr) const           { return (mPointer < ptr.mPointer);  }
  87. bool operator > (const LLSafeHandle<Type>& ptr) const           { return (mPointer > ptr.mPointer);  }
  88. LLSafeHandle<Type>& operator =(Type* ptr)                   
  89. assign(ptr);
  90. return *this; 
  91. }
  92. LLSafeHandle<Type>& operator =(const LLSafeHandle<Type>& ptr)  
  93. assign(ptr.mPointer);
  94. return *this; 
  95. }
  96. // support assignment up the type hierarchy. See Item 45 in Effective C++, 3rd Ed.
  97. template<typename Subclass>
  98. LLSafeHandle<Type>& operator =(const LLSafeHandle<Subclass>& ptr)  
  99. assign(ptr.get());
  100. return *this; 
  101. }
  102. public:
  103. typedef Type* (*NullFunc)();
  104. static const NullFunc sNullFunc;
  105. protected:
  106. void ref()                             
  107. if (mPointer)
  108. {
  109. mPointer->ref();
  110. }
  111. }
  112. void unref()
  113. {
  114. if (mPointer)
  115. {
  116. Type *tempp = mPointer;
  117. mPointer = NULL;
  118. tempp->unref();
  119. if (mPointer != NULL)
  120. {
  121. llwarns << "Unreference did assignment to non-NULL because of destructor" << llendl;
  122. unref();
  123. }
  124. }
  125. }
  126. void assign(Type* ptr)
  127. {
  128. if( mPointer != ptr )
  129. {
  130. unref(); 
  131. mPointer = ptr; 
  132. ref();
  133. }
  134. }
  135. static Type* nonNull(Type* ptr)
  136. {
  137. return ptr == NULL ? sNullFunc() : ptr;
  138. }
  139. protected:
  140. Type* mPointer;
  141. };
  142. #endif