Branch data     Line data    Source code

       1                 :            : //-       Class: MemoryBlock
       2                 :            : //-       Owner: Jim Hipp
       3                 :            : //- Description: MemoryBlock provides stack storage for block or "Chunk"
       4                 :            : //-              memory allocated with overloaded 'new' operators in classes
       5                 :            : //-              utilizing a MemoryManager object.
       6                 :            : //- Checked By: 
       7                 :            : //-    Version:
       8                 :            : 
       9                 :            : #ifndef MEMORY_BLOCK_HPP
      10                 :            : #define MEMORY_BLOCK_HPP
      11                 :            : 
      12                 :            : #include <cstdlib>
      13                 :            : #include "CGMUtilConfigure.h"
      14                 :            : 
      15                 :            : class CUBIT_UTIL_EXPORT MemoryBlock
      16                 :            : {
      17                 :            :   private:
      18                 :            : 
      19                 :            :     char*        block;
      20                 :            :     int          size;
      21                 :            :     MemoryBlock* next;
      22                 :            :     //- block is the pointer to the beginning of the memory block of objects
      23                 :            :     //- of type char, size is the size of the memory block, and next is a
      24                 :            :     //- pointer to the next MemoryBlock object.
      25                 :            : 
      26                 :            :   public:
      27                 :            : 
      28                 :          0 :     MemoryBlock (MemoryBlock* Head, char* Block, int Size)
      29                 :          0 :     : block(Block), size(Size), next(Head) {}
      30                 :            :     //- Constructor: performs initialization assignment
      31                 :            : 
      32                 :            :    ~MemoryBlock();
      33                 :            :     //- Destructor: performs recursive delete of MemoryBlock stack
      34                 :            : 
      35                 :            :     int get_memory_allocation();
      36                 :            :     //- returns total amount of allocated memory (bytes)
      37                 :            : 
      38                 :            :     MemoryBlock* next_block() const;
      39                 :            :     void         next_block(MemoryBlock* next_block);
      40                 :            :     //- retreive / set next pointer
      41                 :            : 
      42                 :            :     int block_size() const;
      43                 :            :     //- get block_size
      44                 :            : 
      45                 :            :     char* get_block() const;
      46                 :            :     //- get block
      47                 :            : };
      48                 :            : 
      49                 :          0 : inline MemoryBlock* MemoryBlock::next_block() const
      50                 :            : {
      51                 :          0 :   return next;
      52                 :            : }
      53                 :            : 
      54                 :          0 : inline void         MemoryBlock::next_block(MemoryBlock* nxt_blck)
      55                 :            : {
      56                 :          0 :   next = nxt_blck;
      57                 :          0 : }
      58                 :            : 
      59                 :          0 : inline int          MemoryBlock::block_size() const
      60                 :            : {
      61                 :          0 :   return size;
      62                 :            : }
      63                 :            : 
      64                 :          0 : inline char*        MemoryBlock::get_block() const
      65                 :            : {
      66                 :          0 :   return block;
      67                 :            : }
      68                 :            : 
      69                 :            : #endif // MEMORY_BLOCK_HPP
      70                 :            :