0024533: Use 0 to check null handle instead of UndefinedHandleAccess
[occt.git] / src / Standard / Handle_Standard_Transient.hxx
1 // Copyright (c) 1998-1999 Matra Datavision
2 // Copyright (c) 1999-2014 OPEN CASCADE SAS
3 //
4 // This file is part of Open CASCADE Technology software library.
5 //
6 // This library is free software; you can redistribute it and / or modify it
7 // under the terms of the GNU Lesser General Public version 2.1 as published
8 // by the Free Software Foundation, with special exception defined in the file
9 // OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
10 // distribution for complete text of the license and disclaimer of any warranty.
11 //
12 // Alternatively, this file may be used under the terms of Open CASCADE
13 // commercial license or contractual agreement.
14
15 #ifndef _Handle_Standard_Transient_HeaderFile
16 #define _Handle_Standard_Transient_HeaderFile
17 #ifndef _Standard_HeaderFile
18 #include <Standard.hxx>
19 #endif
20 #ifndef _Standard_DefineAlloc_HeaderFile
21 #include <Standard_DefineAlloc.hxx>
22 #endif
23 #ifndef _Standard_Macro_HeaderFile
24 #include <Standard_Macro.hxx>
25 #endif
26 #ifndef _Standard_PrimitiveTypes_HeaderFile
27 #include <Standard_PrimitiveTypes.hxx>
28 #endif
29 #ifndef _Standard_Transient_proto_HeaderFile
30 #include <Standard_Transient_proto.hxx>
31 #endif
32
33 #ifdef _WIN32
34 // Disable the warning "conversion from 'unsigned int' to Standard_Transient *"
35 #pragma warning (push)
36 #pragma warning (disable:4312)
37 #endif
38
39 class Handle_Standard_Transient;
40
41 Standard_EXPORT Standard_Integer HashCode(const Handle(Standard_Transient)& ,const Standard_Integer);
42
43 /** 
44  * Base class for hierarchy of smart pointers (Handles) for Transient
45  * objects. Uses reference counting technique to control life time
46  * of the referred object.
47  *
48  * Note that Handle should never be initialized by pointer to object
49  * created in the stack; only dinamically allocated pointers shall be used. 
50  */
51      
52 class Handle(Standard_Transient)
53 {
54 public:
55   
56   // Public methods
57   
58   //! Empty constructor
59   Handle(Standard_Transient) () 
60     : entity(0) 
61   {
62   }
63
64   //! Constructor from pointer to new object
65   Handle(Standard_Transient) (const Standard_Transient *anItem)
66     : entity ( (Standard_Transient*)anItem )
67   {
68     BeginScope();
69   }
70
71   //! Copy constructor
72   Handle(Standard_Transient) (const Handle(Standard_Transient)& aTid) 
73     : entity ( aTid.entity )
74   {
75     BeginScope();
76   } 
77
78   //! Destructor
79   ~Handle(Standard_Transient)()
80   {
81     EndScope();
82   }
83
84   //! Assignment operator
85   Handle(Standard_Transient)& operator=(const Handle(Standard_Transient)& aHandle)
86   {
87     Assign(aHandle.Access());
88     return *this;
89   }
90
91   //! Assignment operator
92   Handle(Standard_Transient)& operator=(const Standard_Transient* anItem)
93   {
94     Assign(anItem);
95     return *this;
96   }
97
98   //! Nullify the handle
99   void Nullify()
100   {
101     EndScope();
102   }
103
104   //! Check for being null
105   Standard_Boolean IsNull() const
106   {
107     return entity == 0;
108   } 
109
110   //! Returns pointer to referred object
111   Standard_Transient* Access()
112   {
113     return entity;
114   } 
115   
116   //! Returns const pointer to referred object
117   const Standard_Transient* Access() const
118   {
119     return entity;
120   } 
121
122   //! Cast to pointer to referred object
123   operator Standard_Transient*()
124   {
125     return entity;
126   }
127
128   //! Cast to const pointer to referred object
129   operator const Standard_Transient*() const
130   {
131     return entity;
132   }
133
134   //! Member access operator (note non-const)
135   Standard_Transient* operator->() const
136   {
137     return entity;
138   }
139
140   //! Dereferencing operator
141   Standard_Transient& operator*()
142   {
143     return *entity;
144   }
145
146   //! Const dereferencing operator
147   const Standard_Transient& operator*() const
148   {
149     return *entity;
150   }
151
152   //! Check for equality
153   int operator==(const Handle(Standard_Transient)& right) const
154   {
155     return entity == right.entity;
156   }
157
158   //! Check for equality
159   int operator==(const Standard_Transient *right) const
160   {
161     return entity == right;
162   }
163
164   //! Check for equality
165   friend bool operator==(const Standard_Transient *left, const Handle(Standard_Transient)& right)
166   {
167     return left == right.entity;
168   }
169
170   //! Check for inequality
171   bool operator!=(const Handle(Standard_Transient)& right) const
172   {
173     return entity != right.entity;
174   }
175
176   //! Check for inequality
177   bool operator!=(const Standard_Transient *right) const
178   {
179     return entity != right;
180   }
181
182   //! Check for inequality
183   friend bool operator!=(const Standard_Transient *left, const Handle(Standard_Transient)& right)
184   {
185     return left != right.entity;
186   }
187
188   //! Down casting operator; dummy provided for consistency with other classes
189   //! (descendants)
190   static const Handle(Standard_Transient)& DownCast(const Handle(Standard_Transient)& AnObject)
191   { 
192     return AnObject;
193   }
194
195   //! Dump pointer to a referred object to a stream
196   Standard_EXPORT void Dump(Standard_OStream& out) const;
197
198 protected:
199   // Protected methods for descendants
200
201   //! Returns non-const pointer to referred object
202   Standard_Transient* ControlAccess() const
203   {
204     return entity;
205   } 
206
207   //! Assignment
208   Standard_EXPORT void Assign (const Standard_Transient *anItem);
209   
210 private:
211   // Private methods
212
213   //! Increment reference counter of referred object 
214   Standard_EXPORT void BeginScope();
215
216   //! Decrement reference counter and if 0, destroy referred object
217   Standard_EXPORT void EndScope();
218
219 public:
220
221   DEFINE_STANDARD_ALLOC
222
223 private:
224   // Field
225   Standard_Transient *entity;
226 };
227
228 //! Function in global scope to check handles for equality.
229 //! Will be used with standard OCCT collections like NCollection_DataMap within NCollection_DefaultHasher
230 //! when there are no specialization defined for concrete type.
231 //! Notice that this implementation compares only pointers to objects!
232 inline Standard_Boolean IsEqual (const Handle(Standard_Transient)& theFirst,
233                                  const Handle(Standard_Transient)& theSecond)
234 {
235   return theFirst == theSecond;
236 }
237
238 #ifdef _WIN32
239 #pragma warning (pop)
240 #endif
241
242 #endif