Xalan-C++ API Documentation

The Xalan C++ XSLT Processor Version 1.10

XalanMemMgrAutoPtr.hpp
Go to the documentation of this file.
1 /*
2  * Copyright 1999-2004 The Apache Software Foundation.
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  * http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16 #if !defined(XALANMEMMGRAUTOPTR_HEADER_GUARD_1357924680)
17 #define XALANMEMMGRAUTOPTR_HEADER_GUARD_1357924680
18 
19 
20 
21 // Base include file. Must be first.
23 
24 
25 
27 
28 #include <cstddef>
29 
30 #include <cassert>
31 
32 #include <utility>
33 
34 
35 
36 XALAN_CPP_NAMESPACE_BEGIN
37 
38 
39 
40 XALAN_USING_XERCES(MemoryManager)
41 
42 // An auto_ptr-like class that supports the MemoryManager class.
43 template<
44  class Type,
45  bool toCallDestructor = true>
47 {
48 public:
49 
50  typedef XALAN_STD_QUALIFIER pair<MemoryManager*, Type*> AutoPtrPairType;
51 
52  class MemMgrAutoPtrData : public AutoPtrPairType
53  {
54  public:
56  AutoPtrPairType(0,0)
57  {
58  }
59 
61  MemoryManager* memoryManager,
62  Type* dataPointer):
63  AutoPtrPairType(memoryManager, dataPointer)
64  {
65  invariants();
66  }
67 
68  bool
69  isInitilized()const
70  {
71  return this->first != 0 && this->second != 0;
72  }
73 
74  void
75  deallocate()
76  {
77  invariants();
78 
79  if ( isInitilized() )
80  {
81  if ( toCallDestructor )
82  {
83  this->second->~Type();
84  }
85 
86  this->first->deallocate(this->second);
87  }
88  }
89 
90  void
91  reset(
92  MemoryManager* memoryManager ,
93  Type* dataPointer)
94  {
95  invariants();
96 
97  this->first = memoryManager;
98 
99  this->second = dataPointer;
100 
101  invariants();
102  }
103 
104  private:
105 
106  void
107  invariants() const
108  {
109  assert(
110  isInitilized() ||
111  (this->first == 0 && this->second == 0));
112  }
113  };
114 
115 
116  XalanMemMgrAutoPtr(
117  MemoryManager& theManager,
118  Type* ptr) :
119  m_pointerInfo(&theManager, ptr)
120  {
121  }
122 
123  XalanMemMgrAutoPtr() :
124  m_pointerInfo()
125  {
126  }
127 
128  XalanMemMgrAutoPtr(const XalanMemMgrAutoPtr<Type, toCallDestructor>& theSource) :
129  m_pointerInfo(((XalanMemMgrAutoPtr<Type>&)theSource).release())
130  {
131  }
132 
135  {
136  if (this != &theRHS)
137  {
138  m_pointerInfo.deallocate();
139 
140  m_pointerInfo = theRHS.release();
141  }
142 
143  return *this;
144  }
145 
146  ~XalanMemMgrAutoPtr()
147  {
148  m_pointerInfo.deallocate();
149  }
150 
151  Type&
152  operator*() const
153  {
154  return *m_pointerInfo.second;
155  }
156 
157  Type*
158  operator->() const
159  {
160  return m_pointerInfo.second;
161  }
162 
163  Type*
164  get() const
165  {
166  return m_pointerInfo.second;
167  }
168 
169  MemoryManager*
170  getMemoryManager()
171  {
172  return m_pointerInfo.first;
173  }
174 
175  const MemoryManager*
176  getMemoryManager() const
177  {
178  return m_pointerInfo.first;
179  }
180 
181  MemMgrAutoPtrData
182  release()
183  {
184  MemMgrAutoPtrData tmp = m_pointerInfo;
185 
186  m_pointerInfo.reset(0, 0);
187 
188  return MemMgrAutoPtrData(tmp);
189  }
190 
191  Type*
192  releasePtr()
193  {
194  MemMgrAutoPtrData tmp = release();
195 
196  return tmp.second;
197  }
198 
199  void
200  reset(
201  MemoryManager* theManager = 0,
202  Type* thePointer = 0)
203  {
204  m_pointerInfo.deallocate();
205 
206  m_pointerInfo.reset(theManager, thePointer);
207  }
208 
209 private:
210 
211  // data member
212  MemMgrAutoPtrData m_pointerInfo;
213 };
214 
215 
216 
217 
218 template<class Type>
220 {
221 public:
222 
223 #if defined(XALAN_STRICT_ANSI_HEADERS)
224  typedef std::size_t size_type;
225 #else
226  typedef size_t size_type;
227 #endif
228 
230  {
231  public:
232 
234  m_memoryManager(0),
235  m_dataArray(0),
236  m_size(0)
237  {
238  }
239 
241  MemoryManager* memoryManager,
242  Type* dataPointer,
243  size_type size):
244  m_memoryManager(memoryManager),
245  m_dataArray(dataPointer),
246  m_size(size)
247  {
248  invariants();
249  }
250 
251  bool
253  {
254  return m_memoryManager != 0 && m_dataArray != 0 && m_size != 0;
255  }
256 
257  void
259  {
260  invariants();
261 
262  if ( isInitilized() )
263  {
264  assert ( m_dataArray != 0 );
265 
266  for ( size_type i = 0; i < m_size ; ++i )
267  {
268  m_dataArray[i].~Type();
269  }
270 
271  m_memoryManager->deallocate(m_dataArray);
272  }
273  }
274 
275  void
277  MemoryManager* theMemoryManager,
278  Type* thePointer,
279  size_type size)
280  {
281  invariants();
282 
283  m_memoryManager = theMemoryManager;
284 
285  m_dataArray = thePointer;
286 
287  m_size = size;
288 
289  invariants();
290  }
291 
292  MemoryManager* m_memoryManager;
293 
294  Type* m_dataArray;
295 
297 
298  private:
299 
300  void
301  invariants()const
302  {
303  assert(
304  isInitilized() ||
305  (m_memoryManager == 0 && m_dataArray == 0 && m_size == 0));
306  }
307  };
308 
310  MemoryManager& theManager,
311  Type* ptr,
312  size_type size) :
313  m_pointerInfo(
314  &theManager,
315  ptr,
316  size)
317  {
318  }
319 
321  m_pointerInfo()
322  {
323  }
324 
326  m_pointerInfo(((XalanMemMgrAutoPtr<Type>&)theSource).release())
327  {
328  }
329 
332  {
333  if (this != &theRHS)
334  {
335  m_pointerInfo.deallocate();
336 
337  m_pointerInfo = theRHS.release();
338  }
339 
340  return *this;
341  }
342 
344  {
345  m_pointerInfo.deallocate();
346  }
347 
348  Type&
349  operator*() const
350  {
351  return *m_pointerInfo.m_dataArray;
352  }
353 
354  Type*
355  operator->() const
356  {
357  return m_pointerInfo.m_dataArray;
358  }
359 
360  Type*
361  get() const
362  {
363  return m_pointerInfo.m_dataArray;
364  }
365 
366  size_type
367  getSize()const
368  {
369  return m_pointerInfo.m_size;
370  }
371 
372  MemoryManager*
374  {
375  return m_pointerInfo.m_memoryManager;
376  }
377 
378  const MemoryManager*
380  {
381  return m_pointerInfo.m_memoryManager;
382  }
383 
386  {
387  ++m_pointerInfo.m_size;
388 
389  return *this;
390  }
391 
392  /* Since this class is not reference-counted, I don't see how this
393  could work, since the destruction of the temporary will free
394  the controlled pointer.
395  XalanMemMgrAutoPtrArray<Type>
396  operator++ (int)
397  {
398  XalanMemMgrAutoPtrArray<Type> temp = *this;
399  ++*this;
400 
401  return temp;
402  }
403  */
404 
405  MemMgrAutoPtrArrayData
407  {
408  MemMgrAutoPtrArrayData tmp = m_pointerInfo;
409 
410  m_pointerInfo.reset(0, 0, 0);
411 
412  return MemMgrAutoPtrArrayData(tmp);
413  }
414 
415  Type*
417  {
418  MemMgrAutoPtrArrayData tmp = release();
419 
420  return tmp.m_dataArray;
421  }
422 
423  void
425  MemoryManager* theManager = 0,
426  Type* thePointer = 0 ,
427  size_type size = 0)
428  {
429  m_pointerInfo.deallocate();
430 
431  m_pointerInfo.reset(theManager, thePointer, size);
432  }
433 
434  Type&
435  operator[](size_type index) const
436  {
437  return m_pointerInfo.m_dataArray[index];
438  }
439 
440 private:
441 
442  // data member
443  MemMgrAutoPtrArrayData m_pointerInfo;
444 };
445 
446 
447 
448 
449 XALAN_CPP_NAMESPACE_END
450 
451 
452 
453 #endif // if !defined(XALANMEMMGRAUTOPTR_HEADER_GUARD_1357924680)

Interpreting class diagrams

Doxygen and GraphViz are used to generate this API documentation from the Xalan-C header files.

dot

Xalan-C++ XSLT Processor Version 1.10
Copyright © 1999-2004 The Apache Software Foundation. All Rights Reserved.

Apache Logo