New Caching Mechanism

class  e_Cache;

class  e_CacheSlot {

    friend  class  e_Cache;

public :
    e_CacheSlot(  int  slotSize )
    {
        slot_size  =  slotSize;
        slot_mem  =   new   char  [ slot_size ];
        next_slot  =  NULL;
        last_time  =   0 ;
        file_id  =   0 ;
        locked  =   0 ;
    }

     virtual   ~ e_CacheSlot()
    {
         if ( slot_mem )
        {
            delete [] slot_mem;
            slot_mem  =  NULL;
        }
    }

     virtual   void     deleteThis()  =   0 ;

     void     clearThis()
    {
         //     backup slot_mem to disk and delete the memory

         char     file_name[ MAX_FILE_NAME_LEN ];

        sprintf( file_name,  " %d " , file_id );
        
        FILE     * fp  =  fopen( file_name,  " wb "  );

        fwrite( slot_mem, slot_size,  1 , fp );

        fclose( fp );

        delete [] slot_mem;
        slot_mem  =  NULL;
    }

     void     accessBegin( e_Cache  * pCache )
    {
         ++  locked;

         if ( slot_mem  ==  NULL )
        {
             //     allocate memory

            slot_mem  =   new   char  [ slot_size ];

             //     reload data from disk

             char     file_name[ MAX_FILE_NAME_LEN ];

            sprintf( file_name,  " %d " , file_id );
        
            FILE     * fp  =  fopen( file_name,  " rb "  );

            fread( slot_mem, slot_size,  1 , fp );

            fclose( fp );

             //     delete oldest item

            pCache -> purge_memory( slot_size );
        }
    }

     void     accessEnd( e_Cache  * pCache )
    {
        last_time  =  pCache -> get_current_time();

         --  locked;
    }

public :
     char              * slot_mem;

private :
    e_CacheSlot         * next_slot;
     int                 slot_size;
    ULONG            last_time;
     int                 file_id;
     int                 locked;
};

//     a cache for a thread, each thread should has its own cache by this design
class  e_Cache {
public :
    e_Cache(  int  cacheSize )
    {
        slots  =  NULL;
        limit  =  cacheSize;
        current_time  =   0 ;
        current_file_id  =   0 ;
        memory_size  =   0 ;
    }

     ~ e_Cache()
    {
        e_CacheSlot     * pSlot;

         while ( ( pSlot  =  slots )  !=  NULL )
        {
            slots  =  pSlot -> next;

            pSlot -> deleteThis();
        }
    }

    ULONG    get_current_time()
    {
         return  (  ++  current_time );
    }

     void     add_slot( e_CacheSlot  * newSlot )
    {
         if ( newSlot )
        {
            newSlot -> next_slot  =  slots;
            slots  =  newSlot;
            newSlot -> file_id  =  (  ++  current_file_id );

            purge_memory( newSlot -> slot_size );
        }
    }

     void     purge_memory(  int  newAddSize )
    {
        memory_size  +=  newAddSize;

         //     if there's no enough memory, delete oldest items

         if ( memory_size  >  limit  &&  slots )
        {
            e_CacheSlot         * oldestSlot  =  slots;
            e_CacheSlot         * pSlot  =  slots -> next_slot;

             while ( pSlot )
            {
                 if ( pSlot -> locked  ==   0   &&  pSlot -> last_time  <  oldestSlot -> last_time )
                {
                    oldestSlot  =  pSlot;
                }

                pSlot  =  pSlot -> next_slot;
            }

             if ( oldestSlot -> locked  ==   0  )
            {
                oldestSlot -> clearThis();
                memory_size  -=  oldestSlot -> slot_size;
            }
        }
    }

private :
    e_CacheSlot         * slots;
     int                 limit;
    ULONG            memory_size;
    ULONG            current_time;
     int                 current_file_id;
};