Go to the documentation of this file.00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022 #ifndef __XPATH2MEMORYMANAGER_HPP
00023 #define __XPATH2MEMORYMANAGER_HPP
00024
00025 #include <algorithm>
00026 #include <assert.h>
00027 #include <cstddef>
00028
00029 #include <xqilla/framework/XQillaExport.hpp>
00030
00031 #include <xercesc/framework/MemoryManager.hpp>
00032
00033 XERCES_CPP_NAMESPACE_BEGIN
00034 class DOMNode;
00035 class XMLGrammarPool;
00036 XERCES_CPP_NAMESPACE_END
00037
00038 class VariableStore;
00039 class VariableTypeStore;
00040 class DynamicContext;
00041 class Collation;
00042 class CollationHelper;
00043 class XQillaNSResolver;
00044 class ATDecimalOrDerived;
00045 class StringPool;
00046
00047 class XQILLA_API XPath2MemoryManager : public XERCES_CPP_NAMESPACE_QUALIFIER MemoryManager
00048 {
00049 public:
00050 virtual ~XPath2MemoryManager() {}
00051
00053 virtual void reset() = 0;
00054
00056 virtual const XMLCh* getPooledString(const XMLCh *src) = 0;
00057 virtual const XMLCh* getPooledString(const XMLCh *src, unsigned int length) = 0;
00058 virtual const XMLCh* getPooledString(const char *src) = 0;
00059
00060
00061 #if _XERCES_VERSION >= 30000
00062 virtual void* allocate(XMLSize_t numElements) = 0;
00063 #else
00064 virtual void* allocate(size_t numElements) = 0;
00065 #endif
00066 virtual void deallocate(void* p) = 0;
00067
00069 virtual Collation* createCollation(CollationHelper* helper) = 0;
00070
00072 virtual XQillaNSResolver* createNSResolver(XERCES_CPP_NAMESPACE_QUALIFIER DOMNode *resolverNode) = 0;
00073
00075 virtual VariableTypeStore* createVariableTypeStore() = 0;
00076
00078 virtual ATDecimalOrDerived* createInteger(int value) = 0;
00079
00080 virtual void dumpStatistics() const = 0;
00081 virtual size_t getAllocatedObjectCount() const = 0;
00082 virtual size_t getTotalAllocatedMemory() const = 0;
00083 virtual const StringPool *getStringPool() const = 0;
00084 };
00085
00086 template <class _Tp>
00087 class XQillaAllocator
00088 {
00089 public:
00090 typedef size_t size_type;
00091 typedef ptrdiff_t difference_type;
00092 typedef _Tp* pointer;
00093 typedef const _Tp* const_pointer;
00094 typedef _Tp& reference;
00095 typedef const _Tp& const_reference;
00096 typedef _Tp value_type;
00097
00098 template <class _Tp1> struct rebind {
00099 typedef XQillaAllocator<_Tp1> other;
00100 };
00101
00102
00103 XQillaAllocator()
00104 {
00105 assert(false);
00106 }
00107
00108 XQillaAllocator(XERCES_CPP_NAMESPACE_QUALIFIER MemoryManager* memMgr)
00109 {
00110 _memMgr=memMgr;
00111 }
00112
00113
00114 XQillaAllocator(const XQillaAllocator<_Tp>& o)
00115 {
00116 _memMgr=o._memMgr;
00117 }
00118 #if _MSC_VER >= 1500
00119
00120 template<class _Tp1> XQillaAllocator(const XQillaAllocator<_Tp1>& o)
00121 {
00122 _memMgr = o._memMgr;
00123 }
00124 #endif
00125 pointer allocate(size_t _n, const void* = 0)
00126 {
00127 if(_n==1)
00128 return (pointer)_singleton;
00129
00130 if(_memMgr)
00131 return _n != 0 ? static_cast<pointer>(_memMgr->allocate(_n*sizeof(_Tp))) : 0;
00132 else
00133 return _n != 0 ? static_cast<pointer>(malloc(_n*sizeof(_Tp))) : 0;
00134 }
00135
00136 void deallocate(void* _p, size_t _n)
00137 {
00138
00139 if(_p) {
00140 if(_p!=_singleton) {
00141 if(_memMgr)
00142 _memMgr->deallocate(_p);
00143 else
00144 free(_p);
00145 }
00146 }
00147 }
00148
00149 void construct(pointer _p, const_reference _v)
00150 {
00151 new ((void *)_p) _Tp(_v);
00152 }
00153
00154 void destroy(pointer _p)
00155 {
00156 _p->~_Tp();
00157 }
00158
00159 size_type max_size() const
00160 {
00161 return 0xFFFFFFFF;
00162 }
00163
00164 size_type max_size(size_type) const
00165 {
00166 return 0xFFFFFFFF;
00167 }
00168
00169 char _singleton[sizeof(_Tp)];
00170 XERCES_CPP_NAMESPACE_QUALIFIER MemoryManager* _memMgr;
00171 };
00172
00173
00174
00175
00176
00177
00178
00179 inline void * operator new(size_t amt, XERCES_CPP_NAMESPACE_QUALIFIER MemoryManager* memMgr)
00180 {
00181 void *p = memMgr->allocate(amt);
00182 return p;
00183 }
00184
00185 inline void operator delete(void* ptr, XERCES_CPP_NAMESPACE_QUALIFIER MemoryManager* memMgr)
00186 {
00187 memMgr->deallocate(ptr);
00188 }
00189
00190 template<class TYPE>
00191 class AutoRelease
00192 {
00193 public:
00194 AutoRelease(TYPE *p)
00195 : p_(p) {}
00196 ~AutoRelease()
00197 {
00198 if(p_ != 0)
00199 p_->release();
00200 }
00201
00202 TYPE &operator*() const
00203 {
00204 return *p_;
00205 }
00206 TYPE *operator->() const
00207 {
00208 return p_;
00209 }
00210 operator TYPE*() const
00211 {
00212 return p_;
00213 }
00214 TYPE *get() const
00215 {
00216 return p_;
00217 }
00218 TYPE *adopt()
00219 {
00220 TYPE *tmp = p_;
00221 p_ = 0;
00222 return tmp;
00223 }
00224 TYPE *swap(TYPE *p)
00225 {
00226 TYPE *tmp = p_;
00227 p_ = p;
00228 return tmp;
00229 }
00230 void set(TYPE *p)
00231 {
00232 if(p_ != 0)
00233 p_->release();
00234 p_ = p;
00235 }
00236
00237 private:
00238 AutoRelease(const AutoRelease<TYPE> &);
00239 AutoRelease<TYPE> &operator=(const AutoRelease<TYPE> &);
00240
00241 TYPE *p_;
00242 };
00243
00244 template<class TYPE>
00245 class AutoDelete
00246 {
00247 public:
00248 AutoDelete(TYPE *p)
00249 : p_(p) {}
00250 ~AutoDelete()
00251 {
00252 delete p_;
00253 }
00254
00255 TYPE &operator*() const
00256 {
00257 return *p_;
00258 }
00259 TYPE *operator->() const
00260 {
00261 return p_;
00262 }
00263 operator TYPE*() const
00264 {
00265 return p_;
00266 }
00267 TYPE *get() const
00268 {
00269 return p_;
00270 }
00271 TYPE *adopt()
00272 {
00273 TYPE *tmp = p_;
00274 p_ = 0;
00275 return tmp;
00276 }
00277 TYPE *swap(TYPE *p)
00278 {
00279 TYPE *tmp = p_;
00280 p_ = p;
00281 return tmp;
00282 }
00283 void set(TYPE *p)
00284 {
00285 delete p_;
00286 p_ = p;
00287 }
00288
00289 private:
00290 AutoDelete(const AutoDelete<TYPE> &);
00291 AutoDelete<TYPE> &operator=(const AutoDelete<TYPE> &);
00292
00293 TYPE *p_;
00294 };
00295
00296 template<class TYPE>
00297 class AutoDeleteArray
00298 {
00299 public:
00300 AutoDeleteArray(TYPE *p)
00301 : p_(p) {}
00302 ~AutoDeleteArray()
00303 {
00304 delete [] p_;
00305 }
00306
00307 TYPE &operator*() const
00308 {
00309 return *p_;
00310 }
00311 TYPE *operator->() const
00312 {
00313 return p_;
00314 }
00315 operator TYPE*() const
00316 {
00317 return p_;
00318 }
00319 TYPE *get() const
00320 {
00321 return p_;
00322 }
00323 TYPE *adopt()
00324 {
00325 TYPE *tmp = p_;
00326 p_ = 0;
00327 return tmp;
00328 }
00329 TYPE *swap(TYPE *p)
00330 {
00331 TYPE *tmp = p_;
00332 p_ = p;
00333 return tmp;
00334 }
00335 void set(TYPE *p)
00336 {
00337 delete [] p_;
00338 p_ = p;
00339 }
00340
00341 private:
00342 AutoDeleteArray(const AutoDeleteArray<TYPE> &);
00343 AutoDeleteArray<TYPE> &operator=(const AutoDeleteArray<TYPE> &);
00344
00345 TYPE *p_;
00346 };
00347
00348 template<class TYPE>
00349 class AutoDeallocate
00350 {
00351 public:
00352 AutoDeallocate(XERCES_CPP_NAMESPACE_QUALIFIER MemoryManager *mmgr, size_t size = sizeof(TYPE))
00353 : p_(0), mmgr_(mmgr) {
00354 p_ = (TYPE*)mmgr_->allocate(size);
00355 }
00356 AutoDeallocate(TYPE *p, XERCES_CPP_NAMESPACE_QUALIFIER MemoryManager *mmgr)
00357 : p_(p), mmgr_(mmgr) {}
00358 ~AutoDeallocate()
00359 {
00360 if(p_ != 0)
00361 mmgr_->deallocate((void*)p_);
00362 }
00363
00364 TYPE &operator*() const
00365 {
00366 return *p_;
00367 }
00368 TYPE *operator->() const
00369 {
00370 return p_;
00371 }
00372 operator TYPE*() const
00373 {
00374 return p_;
00375 }
00376 TYPE *get() const
00377 {
00378 return p_;
00379 }
00380 TYPE *adopt()
00381 {
00382 TYPE *tmp = p_;
00383 p_ = 0;
00384 return tmp;
00385 }
00386 TYPE *swap(TYPE *p)
00387 {
00388 TYPE *tmp = p_;
00389 p_ = p;
00390 return tmp;
00391 }
00392 void set(TYPE *p)
00393 {
00394 if(p_ != 0)
00395 mmgr_->deallocate((void*)p_);
00396 p_ = p;
00397 }
00398
00399 private:
00400 AutoDeallocate(const AutoDeallocate<TYPE> &);
00401 AutoDeallocate<TYPE> &operator=(const AutoDeallocate<TYPE> &);
00402
00403 TYPE *p_;
00404 XERCES_CPP_NAMESPACE_QUALIFIER MemoryManager *mmgr_;
00405 };
00406
00407 #endif //__XPATH2MEMORYMANAGER_HPP
00408