dune-grid  2.2.0
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 namespace ALUGridSpace
00009 {
00010   template<class T, int length>
00011   class ALUGridFiniteStack ;
00012 }
00013 
00014 namespace Dune {
00015 
00017 template <class Object>
00018 class ALUMemoryProvider
00019 {
00020   enum { maxStackObjects = 256 };
00021   typedef ALUGridSpace :: ALUGridFiniteStack< Object* , maxStackObjects > StackType ;
00022   StackType objStack_ ;
00023 
00024   typedef ALUMemoryProvider < Object > MyType;
00025 
00026   StackType& objStack() { return objStack_ ; }
00027 
00028 public:
00029   typedef Object ObjectType;
00030 
00032   ALUMemoryProvider() {}
00033 
00035   ALUMemoryProvider(const ALUMemoryProvider<Object> & org)
00036     : objStack_( org.objStack_ )
00037   {}
00038 
00040   ~ALUMemoryProvider ();
00041 
00043   template <class FactoryType>
00044   ObjectType * getObject(const FactoryType &factory, int level);
00045 
00047   template <class FactoryType, class EntityImp>
00048   inline ObjectType * getEntityObject(const FactoryType& factory, int level , EntityImp * fakePtr ) 
00049   {
00050     if( objStack().empty() )
00051     {
00052       return ( new ObjectType(EntityImp(factory,level) )); 
00053     }
00054     else
00055     {
00056       return stackObject();
00057     }
00058   }
00059 
00061   ObjectType * getObjectCopy(const ObjectType & org);
00062 
00064   void freeObject (ObjectType * obj);
00065 
00066 protected:
00067   inline ObjectType * stackObject() 
00068   {
00069     assert( ! objStack().empty() );
00070     // finite stack does also return object on pop
00071     return objStack().pop();
00072   }
00073 
00074 };
00075 
00076 
00077 //************************************************************************
00078 //
00079 //  ALUMemoryProvider implementation
00080 //
00081 //************************************************************************
00082 template <class Object> template <class FactoryType>
00083 inline typename ALUMemoryProvider<Object>::ObjectType * 
00084 ALUMemoryProvider<Object>::getObject
00085 (const FactoryType &factory, int level )
00086 {
00087   if( objStack().empty() )
00088   {
00089     return ( new Object (factory, level) ); 
00090   }
00091   else
00092   {
00093     return stackObject();
00094   }
00095 }
00096 
00097 template <class Object>
00098 inline typename ALUMemoryProvider<Object>::ObjectType * 
00099 ALUMemoryProvider<Object>::getObjectCopy
00100 (const ObjectType & org )
00101 {
00102   if( objStack().empty() )
00103   {
00104     return ( new Object (org) ); 
00105   }
00106   else
00107   {
00108     return stackObject();
00109   }
00110 }
00111 
00112 template <class Object>
00113 inline ALUMemoryProvider<Object>::~ALUMemoryProvider()
00114 {
00115   StackType& objStk = objStack_;
00116   while ( ! objStk.empty() )
00117   {
00118     ObjectType * obj = objStk.pop();
00119     delete obj;
00120   }
00121 }
00122 
00123 template <class Object>
00124 inline void ALUMemoryProvider<Object>::freeObject(Object * obj)
00125 {
00126   StackType& stk = objStack();
00127   if( stk.full() ) 
00128     delete obj;
00129   else 
00130     stk.push( obj );
00131 }
00132 
00133 #undef USE_FINITE_STACK
00134 
00135 } // end namespace Dune
00136 
00137 #endif