SourceForge.net Logo
XPath2MemoryManager.hpp
Go to the documentation of this file.
1 /*
2  * Copyright (c) 2001, 2008,
3  * DecisionSoft Limited. All rights reserved.
4  * Copyright (c) 2004, 2011,
5  * Oracle and/or its affiliates. All rights reserved.
6  *
7  * Licensed under the Apache License, Version 2.0 (the "License");
8  * you may not use this file except in compliance with the License.
9  * You may obtain a copy of the License at
10  *
11  * http://www.apache.org/licenses/LICENSE-2.0
12  *
13  * Unless required by applicable law or agreed to in writing, software
14  * distributed under the License is distributed on an "AS IS" BASIS,
15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16  * See the License for the specific language governing permissions and
17  * limitations under the License.
18  */
19 
20 #ifndef __XPATH2MEMORYMANAGER_HPP
21 #define __XPATH2MEMORYMANAGER_HPP
22 
23 #include <algorithm>
24 #include <assert.h>
25 #include <cstddef>
26 
27 #include <xqilla/framework/XQillaExport.hpp>
28 
30 
31 XERCES_CPP_NAMESPACE_BEGIN
32 class DOMNode;
33 class XMLGrammarPool;
34 XERCES_CPP_NAMESPACE_END
35 
36 class VariableStore;
37 class VariableTypeStore;
38 class DynamicContext;
39 class Collation;
40 class CollationHelper;
41 class XQillaNSResolver;
42 class ATDecimalOrDerived;
43 class StringPool;
44 
45 class XQILLA_API XPath2MemoryManager : public XERCES_CPP_NAMESPACE_QUALIFIER MemoryManager
46 {
47 public:
48  virtual ~XPath2MemoryManager() {}
49 
51  virtual void reset() = 0;
52 
54  virtual const XMLCh* getPooledString(const XMLCh *src) = 0;
55  virtual const XMLCh* getPooledString(const XMLCh *src, unsigned int length) = 0;
56  virtual const XMLCh* getPooledString(const char *src) = 0;
57 
58  // from MemoryManager
59 #if _XERCES_VERSION >= 30000
60  virtual void* allocate(XMLSize_t numElements) = 0;
61 #else
62  virtual void* allocate(size_t numElements) = 0;
63 #endif
64  virtual void deallocate(void* p) = 0;
65 
67  virtual Collation* createCollation(CollationHelper* helper) = 0;
68 
70  virtual XQillaNSResolver* createNSResolver(XERCES_CPP_NAMESPACE_QUALIFIER DOMNode *resolverNode) = 0;
71 
73  virtual VariableTypeStore* createVariableTypeStore() = 0;
74 
76  virtual ATDecimalOrDerived* createInteger(int value) = 0;
77 
78  virtual void dumpStatistics() const = 0;
79  virtual size_t getAllocatedObjectCount() const = 0;
80  virtual size_t getTotalAllocatedMemory() const = 0;
81  virtual const StringPool *getStringPool() const = 0;
82 };//XPath2MemoryManager
83 
84 template <class _Tp>
86 {
87 public:
88  typedef size_t size_type;
89  typedef ptrdiff_t difference_type;
90  typedef _Tp* pointer;
91  typedef const _Tp* const_pointer;
92  typedef _Tp& reference;
93  typedef const _Tp& const_reference;
94  typedef _Tp value_type;
95 
96  template <class _Tp1> struct rebind {
98  };
99 
100  // Should never be used - for compiling on AIX only
102  {
103  assert(false);
104  }
105 
106  XQillaAllocator(XERCES_CPP_NAMESPACE_QUALIFIER MemoryManager* memMgr)
107  {
108  _memMgr=memMgr;
109  }
110 
111  // define a copy constructor, because we don't want to copy the singleton object
113  {
114  _memMgr=o._memMgr;
115  }
116 #if _MSC_VER >= 1500
117  // Needed for Visual Studio 2008
118  template<class _Tp1> XQillaAllocator(const XQillaAllocator<_Tp1>& o)
119  {
120  _memMgr = o._memMgr;
121  }
122 #endif
123  pointer allocate(size_t _n, const void* = 0)
124  {
125  if(_n==1)
126  return (pointer)_singleton;
127  //std::cout << "XQillaAllocator::allocate(" << _n << ")" << std::endl;
128  if(_memMgr)
129  return _n != 0 ? static_cast<pointer>(_memMgr->allocate(_n*sizeof(_Tp))) : 0;
130  else
131  return _n != 0 ? static_cast<pointer>(malloc(_n*sizeof(_Tp))) : 0;
132  }
133 
134  void deallocate(void* _p, size_t _n)
135  {
136  //std::cout << "XQillaAllocator::deallocate(" << _n << ")" << std::endl;
137  if(_p) {
138  if(_p!=_singleton) {
139  if(_memMgr)
140  _memMgr->deallocate(_p);
141  else
142  free(_p);
143  }
144  }
145  }
146 
148  {
149  new ((void *)_p) _Tp(_v);
150  }
151 
152  void destroy(pointer _p)
153  {
154  _p->~_Tp();
155  }
156 
158  {
159  return 0xFFFFFFFF;
160  }
161 
163  {
164  return 0xFFFFFFFF;
165  }
166 
167  bool operator==(const XQillaAllocator<_Tp>& o) const
168  {
169  return &o == this;
170  }
171 
172  bool operator!=(const XQillaAllocator<_Tp>& o) const
173  {
174  return &o != this;
175  }
176 
178  {
179  return _memMgr != o._memMgr;
180  }
181 
182  char _singleton[sizeof(_Tp)];
183  XERCES_CPP_NAMESPACE_QUALIFIER MemoryManager* _memMgr;
184 };
185 
186 // ---------------------------------------------------------------------------
187 //
188 // Operator new. Global overloaded version, lets any object be allocated on
189 // the heap owned by a MemoryManager.
190 //
191 // ---------------------------------------------------------------------------
192 inline void * operator new(size_t amt, XERCES_CPP_NAMESPACE_QUALIFIER MemoryManager* memMgr)
193 {
194  void *p = memMgr->allocate(amt);
195  return p;
196 }
197 
198 inline void operator delete(void* ptr, XERCES_CPP_NAMESPACE_QUALIFIER MemoryManager* memMgr)
199 {
200  memMgr->deallocate(ptr);
201 }
202 
203 template<class TYPE>
205 {
206 public:
207  AutoRelease(TYPE *p)
208  : p_(p) {}
210  {
211  if(p_ != 0)
212  p_->release();
213  }
214 
215  TYPE &operator*() const
216  {
217  return *p_;
218  }
219  TYPE *operator->() const
220  {
221  return p_;
222  }
223  operator TYPE*() const
224  {
225  return p_;
226  }
227  TYPE *get() const
228  {
229  return p_;
230  }
231  TYPE *adopt()
232  {
233  TYPE *tmp = p_;
234  p_ = 0;
235  return tmp;
236  }
237  TYPE *swap(TYPE *p)
238  {
239  TYPE *tmp = p_;
240  p_ = p;
241  return tmp;
242  }
243  void set(TYPE *p)
244  {
245  if(p_ != 0)
246  p_->release();
247  p_ = p;
248  }
249 
250 private:
252  AutoRelease<TYPE> &operator=(const AutoRelease<TYPE> &);
253 
254  TYPE *p_;
255 };
256 
257 template<class TYPE>
259 {
260 public:
261  AutoDelete(TYPE *p)
262  : p_(p) {}
264  {
265  delete p_;
266  }
267 
268  TYPE &operator*() const
269  {
270  return *p_;
271  }
272  TYPE *operator->() const
273  {
274  return p_;
275  }
276  operator TYPE*() const
277  {
278  return p_;
279  }
280  TYPE *get() const
281  {
282  return p_;
283  }
284  TYPE *adopt()
285  {
286  TYPE *tmp = p_;
287  p_ = 0;
288  return tmp;
289  }
290  TYPE *swap(TYPE *p)
291  {
292  TYPE *tmp = p_;
293  p_ = p;
294  return tmp;
295  }
296  void set(TYPE *p)
297  {
298  delete p_;
299  p_ = p;
300  }
301 
302 private:
303  AutoDelete(const AutoDelete<TYPE> &);
304  AutoDelete<TYPE> &operator=(const AutoDelete<TYPE> &);
305 
306  TYPE *p_;
307 };
308 
309 template<class TYPE>
311 {
312 public:
314  : p_(p) {}
316  {
317  delete [] p_;
318  }
319 
320  TYPE &operator*() const
321  {
322  return *p_;
323  }
324  TYPE *operator->() const
325  {
326  return p_;
327  }
328  operator TYPE*() const
329  {
330  return p_;
331  }
332  TYPE *get() const
333  {
334  return p_;
335  }
336  TYPE *adopt()
337  {
338  TYPE *tmp = p_;
339  p_ = 0;
340  return tmp;
341  }
342  TYPE *swap(TYPE *p)
343  {
344  TYPE *tmp = p_;
345  p_ = p;
346  return tmp;
347  }
348  void set(TYPE *p)
349  {
350  delete [] p_;
351  p_ = p;
352  }
353 
354 private:
356  AutoDeleteArray<TYPE> &operator=(const AutoDeleteArray<TYPE> &);
357 
358  TYPE *p_;
359 };
360 
361 template<class TYPE>
363 {
364 public:
365  AutoDeallocate(XERCES_CPP_NAMESPACE_QUALIFIER MemoryManager *mmgr, size_t size = sizeof(TYPE))
366  : p_(0), mmgr_(mmgr) {
367  p_ = (TYPE*)mmgr_->allocate(size);
368  }
369  AutoDeallocate(TYPE *p, XERCES_CPP_NAMESPACE_QUALIFIER MemoryManager *mmgr)
370  : p_(p), mmgr_(mmgr) {}
372  {
373  if(p_ != 0)
374  mmgr_->deallocate((void*)p_);
375  }
376 
377  TYPE &operator*() const
378  {
379  return *p_;
380  }
381  TYPE *operator->() const
382  {
383  return p_;
384  }
385  operator TYPE*() const
386  {
387  return p_;
388  }
389  TYPE *get() const
390  {
391  return p_;
392  }
393  TYPE *adopt()
394  {
395  TYPE *tmp = p_;
396  p_ = 0;
397  return tmp;
398  }
399  TYPE *swap(TYPE *p)
400  {
401  TYPE *tmp = p_;
402  p_ = p;
403  return tmp;
404  }
405  void set(TYPE *p)
406  {
407  if(p_ != 0)
408  mmgr_->deallocate((void*)p_);
409  p_ = p;
410  }
411 
412 private:
414  AutoDeallocate<TYPE> &operator=(const AutoDeallocate<TYPE> &);
415 
416  TYPE *p_;
417  XERCES_CPP_NAMESPACE_QUALIFIER MemoryManager *mmgr_;
418 };
419 
420 #endif //__XPATH2MEMORYMANAGER_HPP
421