0022815: Missing delete operator for placement new
[occt.git] / src / Standard / Handle_Standard_Transient.hxx
1 #ifndef _Handle_Standard_Transient_HeaderFile
2 #define _Handle_Standard_Transient_HeaderFile
3 #ifndef _Standard_HeaderFile
4 #include <Standard.hxx>
5 #endif
6 #ifndef _Standard_DefineAlloc_HeaderFile
7 #include <Standard_DefineAlloc.hxx>
8 #endif
9 #ifndef _Standard_Macro_HeaderFile
10 #include <Standard_Macro.hxx>
11 #endif
12 #ifndef _Standard_PrimitiveTypes_HeaderFile
13 #include <Standard_PrimitiveTypes.hxx>
14 #endif
15 #ifndef _Standard_Transient_proto_HeaderFile
16 #include <Standard_Transient_proto.hxx>
17 #endif
18
19 #ifdef _WIN32
20 // Disable the warning "conversion from 'unsigned int' to Standard_Transient *"
21 #pragma warning (push)
22 #pragma warning (disable:4312)
23 #endif
24
25 #ifndef UndefinedHandleAddress 
26 #ifdef _OCC64
27 #define UndefinedHandleAddress ((Standard_Transient *)0xfefdfefdfefd0000)
28 #else
29 #define UndefinedHandleAddress ((Standard_Transient *)0xfefd0000)
30 #endif
31 #endif
32
33 class Handle_Standard_Transient;
34
35 Standard_EXPORT Standard_Integer HashCode(const Handle(Standard_Transient)& ,const Standard_Integer);
36
37 /** 
38  * Base class for hierarchy of smart pointers (Handles) for Transient
39  * objects. Uses reference counting technique to control life time
40  * of the referred object.
41  *
42  * Note that Handle should never be initialized by pointer to object
43  * created in the stack; only dinamically allocated pointers shall be used. 
44  */
45      
46 class Handle(Standard_Transient)
47 {
48 public:
49   // Public methods
50   
51   //! Empty constructor
52   Handle(Standard_Transient) () 
53     : entity(UndefinedHandleAddress) 
54   {
55   }
56
57   //! Constructor from pointer to new object
58   Handle(Standard_Transient) (const Standard_Transient *anItem)
59     : entity ( anItem ? (Standard_Transient*)anItem : UndefinedHandleAddress )
60   {
61     BeginScope();
62   }
63
64   //! Copy constructor
65   Handle(Standard_Transient) (const Handle(Standard_Transient)& aTid) 
66     : entity ( aTid.entity )
67   {
68     BeginScope();
69   } 
70
71   //! Destructor
72   Standard_EXPORT ~Handle(Standard_Transient)()
73   {
74     EndScope();
75   }
76
77   //! Assignment operator
78   Handle(Standard_Transient)& operator=(const Handle(Standard_Transient)& aHandle)
79   {
80     Assign(aHandle.Access());
81     return *this;
82   }
83
84   //! Assignment operator
85   Handle(Standard_Transient)& operator=(const Standard_Transient* anItem)
86   {
87     Assign(anItem);
88     return *this;
89   }
90
91   //! Nullify the handle
92   void Nullify()
93   {
94     EndScope();
95   }
96
97   //! Check for being null
98   Standard_Boolean IsNull() const
99   {
100     return entity == UndefinedHandleAddress;
101   } 
102
103   //! Returns pointer to referred object
104   Standard_Transient* Access()
105   {
106     return entity;
107   } 
108   
109   //! Returns const pointer to referred object
110   const Standard_Transient* Access() const
111   {
112     return entity;
113   } 
114
115   //! Cast to pointer to referred object
116   operator Standard_Transient*()
117   {
118     return entity;
119   }
120
121   //! Cast to const pointer to referred object
122   operator const Standard_Transient*() const
123   {
124     return entity;
125   }
126
127   //! Member access operator (note non-const)
128   Standard_Transient* operator->() const
129   {
130     return entity;
131   }
132
133   //! Dereferencing operator
134   Standard_Transient& operator*()
135   {
136     return *entity;
137   }
138
139   //! Const dereferencing operator
140   const Standard_Transient& operator*() const
141   {
142     return *entity;
143   }
144
145   //! Check for equality
146   int operator==(const Handle(Standard_Transient)& right) const
147   {
148     return entity == right.entity;
149   }
150
151   //! Check for equality
152   int operator==(const Standard_Transient *right) const
153   {
154     return entity == right;
155   }
156
157   //! Check for equality
158   friend int operator==(const Standard_Transient *left, const Handle(Standard_Transient)& right)
159   {
160     return left == right.entity;
161   }
162
163   //! Check for inequality
164   int operator!=(const Handle(Standard_Transient)& right) const
165   {
166     return entity != right.entity;
167   }
168
169   //! Check for inequality
170   int operator!=(const Standard_Transient *right) const
171   {
172     return entity != right;
173   }
174
175   //! Check for inequality
176   friend int operator!=(const Standard_Transient *left, const Handle(Standard_Transient)& right)
177   {
178     return left != right.entity;
179   }
180
181   //! Down casting operator; dummy provided for consistency with other classes
182   //! (descendants)
183   static const Handle(Standard_Transient)& DownCast(const Handle(Standard_Transient)& AnObject)
184   { 
185     return AnObject;
186   }
187
188   //! Dump pointer to a referred object to a stream
189   Standard_EXPORT void Dump(Standard_OStream& out) const;
190
191 protected:
192   // Protected methods for descendants
193
194   //! Returns non-const pointer to referred object
195   Standard_Transient* ControlAccess() const
196   {
197     return entity;
198   } 
199
200   //! Assignment
201   Standard_EXPORT void Assign (const Standard_Transient *anItem);
202   
203 private:
204   // Private methods
205
206   //! Increment reference counter of referred object 
207   Standard_EXPORT void BeginScope();
208
209   //! Decrement reference counter and if 0, destroy referred object
210   Standard_EXPORT void EndScope();
211
212 public:
213
214   DEFINE_STANDARD_ALLOC
215
216 private:
217   // Field
218   Standard_Transient *entity;
219 };
220
221 #ifdef _WIN32
222 #pragma warning (pop)
223 #endif
224
225 #endif