SourceForge.net Logo
XPath2MemoryManager.hpp
Go to the documentation of this file.
00001 /*
00002  * Copyright (c) 2001-2008
00003  *     DecisionSoft Limited. All rights reserved.
00004  * Copyright (c) 2004-2008
00005  *     Oracle. All rights reserved.
00006  *
00007  * Licensed under the Apache License, Version 2.0 (the "License");
00008  * you may not use this file except in compliance with the License.
00009  * You may obtain a copy of the License at
00010  *
00011  *     http://www.apache.org/licenses/LICENSE-2.0
00012  *
00013  * Unless required by applicable law or agreed to in writing, software
00014  * distributed under the License is distributed on an "AS IS" BASIS,
00015  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
00016  * See the License for the specific language governing permissions and
00017  * limitations under the License.
00018  *
00019  * $Id$
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   // from MemoryManager
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 };//XPath2MemoryManager
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   // Should never be used - for compiling on AIX only
00103   XQillaAllocator()
00104   {
00105     assert(false);
00106   }
00107 
00108   XQillaAllocator(XERCES_CPP_NAMESPACE_QUALIFIER MemoryManager* memMgr)
00109   {
00110     _memMgr=memMgr;
00111   }
00112 
00113   // define a copy constructor, because we don't want to copy the singleton object
00114   XQillaAllocator(const XQillaAllocator<_Tp>& o)
00115   {
00116     _memMgr=o._memMgr;
00117   }
00118 #if _MSC_VER >= 1500
00119   // Needed for Visual Studio 2008      
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     //std::cout << "XQillaAllocator::allocate(" << _n << ")" << std::endl;
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     //std::cout << "XQillaAllocator::deallocate(" << _n << ")" << std::endl;
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 //  Operator new.  Global overloaded version, lets any object be allocated on
00176 //                 the heap owned by a MemoryManager.
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