Main Page   Class Hierarchy   Compound List   File List   Compound Members  

heap.h

00001 #ifndef CMA_HEAP_DEFINED
00002 #define CMA_HEAP_DEFINED
00003 
00004 #include <stdlib.h>
00005 #include <assert.h>
00006 
00007 namespace CMa
00008 {
00043         template<class Word, class Int> class Heap
00044         {
00045         protected:
00046 
00047                 Word* data;
00048                 int MAX;
00049 
00050                 Int SP;
00051                 Int NP;
00052                 Int EP;
00053 
00054         public:
00055 
00056                 Heap()
00057                 {
00058                         data = NULL;
00059                         MAX = 0;
00060                 }
00061 
00074                 void setParams(Int virtualSize, int realSize)
00075                 {
00076                         assert(realSize > 0);
00077                         assert(virtualSize >= (Int)realSize);
00078                         MAX = realSize;
00079                 }
00080 
00081 
00082 
00083                 /* Interfaces used by the templates */
00084 
00086                 void init() throw (Failure)
00087                 {
00088                         data = new Word[MAX];
00089                         if (data == NULL)
00090                                 throw Failure("Not enough memory");
00091 
00092                         SP = (Int)-1;
00093                         NP = (Int)MAX;
00094                         EP = (Int)0;
00095                 }
00096 
00097                 void deInit()
00098                 {
00099                         delete data;
00100                         data = NULL;
00101                 }
00102 
00103                 ~Heap()
00104                 {
00105                         if (data != NULL) delete data;
00106                 }
00107 
00109                 inline Int getSize()
00110                 {
00111                         return MAX;
00112                 }
00113         /******************************************Test*methods******************************************/
00114                 inline bool verifySP(const Int& newSP)
00115                 {
00116                         return (Int(0) <= newSP && newSP <= EP );
00117                 }
00118                 
00119                 inline bool verifyNP(const Int& newNP)
00120                 {
00121                         return (EP < newNP && newNP <(Int)MAX);
00122                 }
00123 
00124                 inline bool verifyEP(const Int& newEP)
00125                 {
00126                         return (SP <= newEP && newEP < NP);
00127                 }
00128                                                 
00129                 inline bool verifyFP(const Int& newFP, const Int& newSP)
00130                 {
00131                         return ((Int)0<= newFP && newFP < newSP);
00132                 }
00133                 
00134                 inline bool verifyAddress(const Int& addr)
00135                 {
00136                         return (((Int)0 <= addr &&  addr<=SP) || (NP<=addr && addr < (Int)MAX));
00137                 }
00138 
00139                 inline bool verifyInterval(const Int& addr1, const Int& addr2)
00140                 {
00141                         //interval is invalid
00142                         if(addr1> addr2) return false;
00143                         //Interval is in the stack
00144                         if(addr1 <= SP) return ((Int)0 <= addr1 && addr2 <= SP);
00145                         //Interval is in the heap
00146                         return (NP<=addr1 && addr2 < (Int)MAX);
00147                 }
00148                 
00149         /*********************************************Get*methods********************************************/
00150                 inline Int getSP() { return SP; }
00151                 inline Int getNP() { return NP; }
00152                 inline Int getEP() { return EP; }
00153 
00154                 /*********************************************Set*Methods********************************************/
00155                 /*                                     NO VALIDITY CHECKS ARE DONE                                  */
00156                 /****************************************************************************************************/
00157                 inline void setSP(const Int& newSP)
00158                 {
00159                         assert(verifySP(newSP));
00160                         SP = newSP;
00161                 }
00162                 
00163                 inline void setNP(const Int& newNP)
00164                 {
00165                         assert(verifyNP(newNP));
00166                         NP = newNP;
00167                 }
00168 
00169                 inline void setEP(const Int& newEP)
00170                 {
00171                         assert(verifyEP(newEP));
00172                         EP = newEP;
00173                 }
00174 
00175 
00176                 /*********************************************Heap*access********************************************/
00177                 /*                            ALL VALIDITY CHECKS MUST BE DONE BEFORE                               */
00178                 /****************************************************************************************************/
00179                 inline Word& operator[](Int addr)
00180                 {
00181                         assert(verifyAddress(addr));
00182                         return data[ addr.convertToint() ];
00183                 }
00184         
00185                 inline Word& top(int offset = 0)
00186                 {
00187                         if(SP < (Int)offset) throw Failure("Error in your code: not so many elements in heap"); 
00188                         return data[ SP.convertToint() - offset];
00189                 }
00190         };
00191  }
00192 
00193 #endif
00194 

Generated on Tue Oct 12 03:30:44 1999 by doxygen1.2.18