dune-grid  2.1.1
memory.hh
Go to the documentation of this file.
00001 #ifndef DUNE_ALU3DGRIDMEMORY_HH
00002 #define DUNE_ALU3DGRIDMEMORY_HH
00003 
00004 #include <cassert>
00005 #include <cstdlib>
00006 #include <vector>
00007 
00008 #include <dune/common/finitestack.hh>
00009 
00010 namespace Dune {
00011 
00013 template <class Object>
00014 class ALUMemoryProvider
00015 {
00016   enum { maxStackObjects = 256 };
00017   typedef FiniteStack< Object* , maxStackObjects > StackType ;
00018 
00019   StackType objStack_ ;
00020 
00021   typedef ALUMemoryProvider < Object > MyType;
00022 
00023   StackType& objStack() { return objStack_ ; }
00024 
00025 public:
00026   typedef Object ObjectType;
00027 
00029   ALUMemoryProvider() {}
00030 
00032   ALUMemoryProvider(const ALUMemoryProvider<Object> & org)
00033     : objStack_( org.objStack_ )
00034   {}
00035 
00037   ~ALUMemoryProvider ();
00038 
00040   template <class FactoryType>
00041   ObjectType * getObject(const FactoryType &factory, int level);
00042 
00044   template <class FactoryType, class EntityImp>
00045   inline ObjectType * getEntityObject(const FactoryType& factory, int level , EntityImp * fakePtr ) 
00046   {
00047     if( objStack().empty() )
00048     {
00049       return ( new ObjectType(EntityImp(factory,level) )); 
00050     }
00051     else
00052     {
00053       return stackObject();
00054     }
00055   }
00056 
00058   ObjectType * getObjectCopy(const ObjectType & org);
00059 
00061   void freeObject (ObjectType * obj);
00062 
00063 protected:
00064   inline ObjectType * stackObject() 
00065   {
00066     assert( ! objStack().empty() );
00067     // finite stack does also return object on pop
00068     return objStack().pop();
00069   }
00070 
00071 };
00072 
00073 
00074 //************************************************************************
00075 //
00076 //  ALUMemoryProvider implementation
00077 //
00078 //************************************************************************
00079 template <class Object> template <class FactoryType>
00080 inline typename ALUMemoryProvider<Object>::ObjectType * 
00081 ALUMemoryProvider<Object>::getObject
00082 (const FactoryType &factory, int level )
00083 {
00084   if( objStack().empty() )
00085   {
00086     return ( new Object (factory, level) ); 
00087   }
00088   else
00089   {
00090     return stackObject();
00091   }
00092 }
00093 
00094 template <class Object>
00095 inline typename ALUMemoryProvider<Object>::ObjectType * 
00096 ALUMemoryProvider<Object>::getObjectCopy
00097 (const ObjectType & org )
00098 {
00099   if( objStack().empty() )
00100   {
00101     return ( new Object (org) ); 
00102   }
00103   else
00104   {
00105     return stackObject();
00106   }
00107 }
00108 
00109 template <class Object>
00110 inline ALUMemoryProvider<Object>::~ALUMemoryProvider()
00111 {
00112   StackType& objStk = objStack_;
00113   while ( ! objStk.empty() )
00114   {
00115     ObjectType * obj = objStk.pop();
00116     delete obj;
00117   }
00118 }
00119 
00120 template <class Object>
00121 inline void ALUMemoryProvider<Object>::freeObject(Object * obj)
00122 {
00123   StackType& stk = objStack();
00124   if( stk.full() ) 
00125     delete obj;
00126   else 
00127     stk.push( obj );
00128 }
00129 
00130 #undef USE_FINITE_STACK
00131 
00132 } // end namespace Dune
00133 
00134 #endif