From 0ea5fc66924303d1bf73ba283a383e2aadee02f2 Mon Sep 17 00:00:00 2001 From: neodarz Date: Sat, 11 Aug 2018 20:21:34 +0200 Subject: Initial commit --- docs/doxygen/nel/a03321.html | 720 +++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 720 insertions(+) create mode 100644 docs/doxygen/nel/a03321.html (limited to 'docs/doxygen/nel/a03321.html') diff --git a/docs/doxygen/nel/a03321.html b/docs/doxygen/nel/a03321.html new file mode 100644 index 00000000..c1074e7a --- /dev/null +++ b/docs/doxygen/nel/a03321.html @@ -0,0 +1,720 @@ + + +NeL: TemplateNLMISC::CRefPtr< T > class Reference + + + +

NLMISC::CRefPtr< T > Class Template Reference

#include <smart_ptr.h> +

Detailed Description

template<class T>
+ class NLMISC::CRefPtr< T >

+ +CRefPtr: an handle on a ptr. T Must derive from CRefCount. If you use CRefPtr, you can kill the object simply by calling delete (T*)RefPtr, or the kill() method. All other CRefPtr which point to it can know if it has been deleted. (but you must be sure that this ptr is not handle by a SmartPtr, of course...)

+SmartPtr are compatible with RefPtr. A ptr may be link to a CRefPtr and a CSmartPtr. As example, when the CSmartPtr will destroy him, CRefPtr will be informed... Sample:

        void    foo()
+        {
+                A                               *p;
+                CSmartPtr<A>    sp;
+                CRefPtr<A>              rp;
+
+                p= new A;
+                sp= p;          // OK. p is now owned by sp and will be deleted by sp.
+                rp= p;          // OK. rp handle p.
+                sp= NULL;       // Destruction. p deleted. rp automatically informed.
+                if(rp==NULL)
+                        thisIsGood();   // rp==NULL.
+        }
+

+PERFORMANCE WARNING! operator=() are about 10 times slower than normal pointers. So use them wisely. For local use, prefer cast the refptr to a normal Ptr. Also, an object used with a CRefPtr will allocate a small PtrInfo (one only per object, not per ptr).

See also:: CSmartPtr

+ +

+Definition at line 256 of file smart_ptr.h. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

Public Member Functions
CRefPtr (const CRefPtr &copy)
Copy constructor.

CRefPtr (T *v)
Attach a ptr to a RefPtr.

CRefPtr ()
Init a NULL Ptr.

void kill ()
T & operator * (void) const
Indirection operator. Doesn't test if ptr has been deleted somewhere, and doesn't check NULL.

operator T * () const
Cast operator. Check if the object has been deleted somewhere, and return NULL if this is the case.

T * operator-> (void) const
Selection operator. Doesn't test if ptr has been deleted somewhere, and doesn't check NULL.

CRefPtr & operator= (const CRefPtr &copy)
operator=. Giving a NULL pointer is a valid operation.

CRefPtr & operator= (T *v)
operator=. Giving a NULL pointer is a valid operation.

~CRefPtr (void)
Release the RefPtr.

Private Member Functions
void unRef () const

Private Attributes
CRefCount::CPtrInfo * pinfo
T * Ptr
+

Constructor & Destructor Documentation

+ + + + +
+ + + + + + + + + + + + +
+template<class T>
NLMISC::CRefPtr< T >::CRefPtr ( ) [inline]
+
+ + + + + +
+ + + +
+Init a NULL Ptr. +
+ +
+Definition at line 153 of file smart_ptr_inline.h. +
+References REF_TRACE. +
+
00154 { +00155 pinfo= &CRefCount::NullPtrInfo; +00156 Ptr= NULL; +00157 +00158 REF_TRACE("Smart()"); +00159 } +

+

+ + + + +
+ + + + + + + + + + + + + +
+template<class T>
NLMISC::CRefPtr< T >::CRefPtr ( T * v ) [inline]
+
+ + + + + +
+ + + +
+Attach a ptr to a RefPtr. +
+ +
+Definition at line 160 of file smart_ptr_inline.h. +
+References REF_TRACE, NLMISC::CRefCount::CPtrInfo::RefCount, and v. +
+
00161 { +00162 Ptr= v; +00163 if(v) +00164 { +00165 // If no CRefPtr handles v, create a pinfo ref... +00166 if(v->pinfo->IsNullPtrInfo) +00167 v->pinfo=new CRefCount::CPtrInfo(v); +00168 pinfo=v->pinfo; +00169 // v is now used by this. +00170 pinfo->RefCount++; +00171 } +00172 else +00173 pinfo= &CRefCount::NullPtrInfo; +00174 +00175 REF_TRACE("Smart(T*)"); +00176 } +

+

+ + + + +
+ + + + + + + + + + + + + +
+template<class T>
NLMISC::CRefPtr< T >::CRefPtr ( const CRefPtr< T > & copy ) [inline]
+
+ + + + + +
+ + + +
+Copy constructor. +
+ +
+Definition at line 177 of file smart_ptr_inline.h. +
+References NLMISC::CRefPtr< T >::pinfo, NLMISC::CRefCount::CPtrInfo::Ptr, REF_TRACE, and NLMISC::CRefCount::CPtrInfo::RefCount. +
+
00178 { +00179 pinfo=copy.pinfo; +00180 pinfo->RefCount++; +00181 Ptr= (T*)pinfo->Ptr; +00182 +00183 REF_TRACE("SmartCopy()"); +00184 } +

+

+ + + + +
+ + + + + + + + + + + + + +
+template<class T>
NLMISC::CRefPtr< T >::~CRefPtr ( void ) [inline]
+
+ + + + + +
+ + + +
+Release the RefPtr. +
+ +
+Definition at line 185 of file smart_ptr_inline.h. +
+References REF_TRACE, and NLMISC::CRefPtr< T >::unRef(). +
+
00186 { +00187 REF_TRACE("~Smart()"); +00188 +00189 unRef(); +00190 pinfo= &CRefCount::NullPtrInfo; +00191 Ptr= NULL; +00192 } +

+

Member Function Documentation

+ + + + +
+ + + + + + + + + + + + +
+template<class T>
void NLMISC::CRefPtr< T >::kill ( )
+
+ + + + + +
+ + + +
+kill/delete the object pointed by the pointer, and inform the other RefPtr of this. "rp.kill()" and "delete (T*)rp" do the same thing, except that rp NULLity is updated with kill(). RefPtr which point to the same object could know if the object is valid, by just testing it ( by an implicit call to the cast operator to T*). But any calls to operator->() or operator*() will have unpredictible effects (may crash... :) ). +
+Definition at line 241 of file smart_ptr_inline.h. +
+References NLMISC::CRefCount::CPtrInfo::Ptr, REF_TRACE, and NLMISC::CRefPtr< T >::unRef(). +
+
00242 { +00243 REF_TRACE("SmartKill"); +00244 +00245 T *ptr= (T*)pinfo->Ptr; +00246 +00247 // First, release the refptr. +00248 unRef(); +00249 pinfo= &CRefCount::NullPtrInfo; +00250 Ptr= NULL; +00251 +00252 // Then delete the pointer. +00253 if(ptr) +00254 delete ptr; +00255 } +

+

+ + + + +
+ + + + + + + + + + + + + +
+template<class T>
T & NLMISC::CRefPtr< T >::operator * ( void ) const [inline]
+
+ + + + + +
+ + + +
+Indirection operator. Doesn't test if ptr has been deleted somewhere, and doesn't check NULL. +
+ +
+Definition at line 272 of file smart_ptr_inline.h. +
+References REF_TRACE. +
+
00273 { +00274 REF_TRACE("Smart *()"); +00275 return *Ptr; +00276 } +

+

+ + + + +
+ + + + + + + + + + + + +
+template<class T>
NLMISC::CRefPtr< T >::operator T * ( ) const [inline]
+
+ + + + + +
+ + + +
+Cast operator. Check if the object has been deleted somewhere, and return NULL if this is the case. +
+ +
+Definition at line 260 of file smart_ptr_inline.h. +
+References NLMISC::CRefCount::CPtrInfo::Ptr, and REF_TRACE. +
+
00261 { +00262 REF_TRACE("SmartCast T*()"); +00263 +00264 // Refresh Ptr. +00265 Ptr= (T*)pinfo->Ptr; +00266 return Ptr; +00267 } +

+

+ + + + +
+ + + + + + + + + + + + + +
+template<class T>
T * NLMISC::CRefPtr< T >::operator-> ( void ) const [inline]
+
+ + + + + +
+ + + +
+Selection operator. Doesn't test if ptr has been deleted somewhere, and doesn't check NULL. +
+ +
+Definition at line 277 of file smart_ptr_inline.h. +
+References REF_TRACE. +
+
00278 { +00279 REF_TRACE("Smart ->()"); +00280 return Ptr; +00281 } +

+

+ + + + +
+ + + + + + + + + + + + + +
+template<class T>
CRefPtr< T > & NLMISC::CRefPtr< T >::operator= ( const CRefPtr< T > & copy )
+
+ + + + + +
+ + + +
+operator=. Giving a NULL pointer is a valid operation. +
+ +
+Definition at line 223 of file smart_ptr_inline.h. +
+References NLMISC::CRefPtr< T >::pinfo, NLMISC::CRefCount::CPtrInfo::Ptr, REF_TRACE, NLMISC::CRefCount::CPtrInfo::RefCount, and NLMISC::CRefPtr< T >::unRef(). +
+
00224 { +00225 REF_TRACE("ope=(Smart)Start"); +00226 +00227 // The auto equality test is implicitly done by upcounting first "copy", then downcounting "this". +00228 copy.pinfo->RefCount++; +00229 unRef(); +00230 pinfo=copy.pinfo; +00231 // Must Refresh the ptr. +00232 Ptr= (T*)pinfo->Ptr; +00233 +00234 REF_TRACE("ope=(Smart)End"); +00235 return *this; +00236 } +

+

+ + + + +
+ + + + + + + + + + + + + +
+template<class T>
CRefPtr< T > & NLMISC::CRefPtr< T >::operator= ( T * v )
+
+ + + + + +
+ + + +
+operator=. Giving a NULL pointer is a valid operation. +
+ +
+Definition at line 196 of file smart_ptr_inline.h. +
+References REF_TRACE, NLMISC::CRefPtr< T >::unRef(), and v. +
+
00197 { +00198 REF_TRACE("ope=(T*)Start"); +00199 +00200 +00201 Ptr= v; +00202 if(v) +00203 { +00204 // If no CRefPtr handles v, create a pinfo ref... +00205 if(v->pinfo->IsNullPtrInfo) +00206 v->pinfo=new CRefCount::CPtrInfo(v); +00207 // The auto equality test is implicitly done by upcounting first "v", then downcounting "this". +00208 v->pinfo->RefCount++; +00209 unRef(); +00210 pinfo= v->pinfo; +00211 } +00212 else +00213 { +00214 unRef(); +00215 pinfo= &CRefCount::NullPtrInfo; +00216 } +00217 +00218 +00219 REF_TRACE("ope=(T*)End"); +00220 +00221 return *this; +00222 } +

+

+ + + + +
+ + + + + + + + + + + + +
+template<class T>
void NLMISC::CRefPtr< T >::unRef ( ) const [inline, private]
+
+ + + + + +
+ + + +
+ +
+Definition at line 121 of file smart_ptr_inline.h. +
+References NLMISC::CRefCount::CPtrInfo::IsNullPtrInfo, NLMISC::CRefCount::CPtrInfo::Ptr, NLMISC::CRefCount::CPtrInfo::RefCount, and SMART_INLINE. +
+Referenced by NLMISC::CRefPtr< T >::kill(), NLMISC::CRefPtr< T >::operator=(), and NLMISC::CRefPtr< T >::~CRefPtr(). +
+
00122 { +00123 pinfo->RefCount--; +00124 if(pinfo->RefCount==0) +00125 { +00126 // In CRefPtr, Never delete the object. +00127 +00128 // We may be in the case that this==NullPtrInfo, and our NullPtrInfo has done a total round. Test it. +00129 if(pinfo->IsNullPtrInfo) +00130 { +00131 // This should not happens, but I'm not sure :) ... +00132 // Reset the NullPtrInfo to a middle round. +00133 pinfo->RefCount= 0x7FFFFFFF; +00134 } +00135 else +00136 { +00137 // If the CRefPtr still point to a valid object. +00138 if(pinfo->Ptr) +00139 { +00140 // Inform the Object that no more CRefPtr points on it. +00141 ((T*)(pinfo->Ptr))->pinfo= &CRefCount::NullPtrInfo; +00142 } +00143 // Then delete the pinfo. +00144 delete pinfo; +00145 } +00146 +00147 } +00148 } +

+

Field Documentation

+ + + + +
+ + + + + +
+template<class T>
CRefCount::CPtrInfo* NLMISC::CRefPtr< T >::pinfo [private] +
+
+ + + + + +
+ + + +
+ +
+Definition at line 259 of file smart_ptr.h. +
+Referenced by NLMISC::CRefPtr< T >::CRefPtr(), and NLMISC::CRefPtr< T >::operator=().
+

+ + + + +
+ + + + + +
+template<class T>
T* NLMISC::CRefPtr< T >::Ptr [mutable, private] +
+
+ + + + + +
+ + + +
+ +
+Definition at line 260 of file smart_ptr.h.
+

The documentation for this class was generated from the following files:

Generated on Tue Mar 16 13:31:38 2004 for NeL by + +

+1.3.6

+ + -- cgit v1.2.1


Public Member Functions
	CRefPtr (const CRefPtr &copy)
	Copy constructor.
	CRefPtr (T *v)
	Attach a ptr to a RefPtr.
	CRefPtr ()
	Init a NULL Ptr.
void	kill ()
T &	operator * (void) const
	Indirection operator. Doesn't test if ptr has been deleted somewhere, and doesn't check NULL.
	operator T * () const
	Cast operator. Check if the object has been deleted somewhere, and return NULL if this is the case.
T *	operator-> (void) const
	Selection operator. Doesn't test if ptr has been deleted somewhere, and doesn't check NULL.
CRefPtr &	operator= (const CRefPtr &copy)
	operator=. Giving a NULL pointer is a valid operation.
CRefPtr &	operator= (T *v)
	operator=. Giving a NULL pointer is a valid operation.
	~CRefPtr (void)
	Release the RefPtr.
Private Member Functions
void	unRef () const
Private Attributes
CRefCount::CPtrInfo *	pinfo
T *	Ptr

NLMISC::CRefPtr< T > Class Template Reference

Detailed Description

template<class T> + class NLMISC::CRefPtr< T >

Public Member Functions

Private Member Functions

Private Attributes

Constructor & Destructor Documentation

Member Function Documentation

Field Documentation

template<class T>
+ class NLMISC::CRefPtr< T >