/net/fileserver/nas/home/mdh/vrq/src/cobstack.h

Go to the documentation of this file.

/*****************************************************************************
 * Copyright (C) 1997-2007, Mark Hummel
 * This file is part of Vrq.
 *
 * Vrq is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public
 * License as published by the Free Software Foundation; either
 * version 2 of the License, or (at your option) any later version.
 *
 * Vrq is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, 
 * Boston, MA  02110-1301  USA
 *****************************************************************************
 */
/******************************************************************************
 *
 *
 *         cobstack.hpp
 *                      - class definition for stack like bulk allocation
 *
 *
 ******************************************************************************
 */

#ifndef COBSTACK_HPP
#define COBSTACK_HPP

#include "glue.h"
#include <string>
#include <vector>
#include <list>
using namespace std;

class CObstack
{
private:
        static  list<CObstack*>* obstackList;   

        typedef struct  obstackChunk_tag {
                struct  obstackChunk_tag *next; 
                long    size;                   
                long    objectOffset;           
                long    freeOffset;             
                char    data[4];                
        } Chunk_t;

        static const    int OBSTACK_DEFAULT_BLOCK_SIZE = 
                                                1024*64; 

        string          name;           
        Chunk_t*        currentChunk;   
        long            alignment;      
        long            defaultSize;    

        int             chunkCount;     
        int             maxChunkCount;  
public:
        static void OnExitDumpStats();
        CObstack( const char* name, int chunkSize = OBSTACK_DEFAULT_BLOCK_SIZE );
        ~CObstack( void );      
        void*   Alloc( INT32 size );
        void    Free( void* object );
        void*   GetBase( void );
        void*   NextFree( void );
        void*   Finish( void );
        void*   Copy( const void* ptr, INT32 size );
        void*   Copy0( const void* ptr, INT32 size );
        INT32   GetObjectSize( void );
        void    Grow( const void* ptr, INT32 size );
        void    Grow( INT32 size );
        void    PtrGrow( void* ptr );
        int     IsOwner( void* ptr );
private:
        static void _OnExitDumpStats();
        void DumpStats();
        void*   GrowChunk( INT32 );
};

template<class T>
inline T** Finalize( CObstack* heap, vector<T*>& v )
{
        typename vector<T*>::iterator ptr;

        for( ptr = v.begin(); ptr != v.end(); ++ptr ) {
                heap->Grow( &*ptr, sizeof(T*) );
        }
        heap->PtrGrow(NULL);
        v.erase( v.begin(), v.end() );
        return (T**)heap->Finish();
}


#endif // COBSTACK_HPP