PtrStack.h

Go to the documentation of this file.

/***************************************************************************
 *   Copyright (C) 2004 by Olivier Stezowski                               *
 *   stezow(AT)ipnl.in2p3.fr                                               *
 *                                                                         *
 *   This program 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.                                   *
 *                                                                         *
 *   This program 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 program; if not, write to the                         *
 *   Free Software Foundation, Inc.,                                       *
 *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
 ***************************************************************************/
 
#ifndef ADF_PtrStack
#define ADF_PtrStack
#define ADF_PTRSTACK_H ADF_PtrStack

#include <memory.h>

namespace ADF
{ 

template <typename T, typename S = UInt_t>
class PtrStack
{
public:
//    const S fDefaultCapacity = 16;
    
private:
// public:
        T **fStack;
        
        S fCurrentSize;  
        S fFilledSize;      
        S fMaxSize;   
        
        Bool_t fIsOwner; 
    
protected:
        void Init();
        void Expand(S);
        
public:
        PtrStack(S max_size = 16): 
                fStack(0x0), fCurrentSize(0), fFilledSize(0), fMaxSize(max_size), fIsOwner(true) { Init(); }
        ~PtrStack();
        
        void SetBottom() 
                { fCurrentSize = 0; } 
        
        void SetOwner(Bool_t own = false) 
                { fIsOwner = own; }
        
        T *At(S which) const
                { if ( which < fMaxSize ) return fStack[which]; return NULL; }
        

        void Add(T *t) 
        { 
                if ( fFilledSize == fMaxSize ) 
                        Expand(fMaxSize+10); 
                if ( fFilledSize < fMaxSize ) { fStack[fFilledSize++] = t; fCurrentSize = fFilledSize; }
        }
                
        //     void Reserve(S size) { if ( size <= fMaxSize ) return;  }
                

        S GetSize() const 
                { return fCurrentSize; }
        

        void Clear() 
        { 
                if ( fStack == NULL || fFilledSize == 0 ) return;       
                for (S i = 0; i < fFilledSize; i++) 
                        fStack[i] = NULL ; 
                fFilledSize = fCurrentSize = 0; 
        }
                

        void Delete();
};
template <typename T, typename S> void PtrStack<T,S>::Init()
{
        if ( fMaxSize <= 0 ) fMaxSize = 1;
        
        if ( fStack ) 
                { delete [] fStack; fStack = NULL; } 
        
        fStack = new T*[fMaxSize]; ::memset(fStack,0,fMaxSize*sizeof(T*)); fFilledSize = 0; fCurrentSize = 0;
}
template <typename T, typename S> void PtrStack<T,S>::Expand(S new_size)
{
        if ( new_size <= fMaxSize  ) return;
        T **tmp = new T*[new_size]; ::memset(tmp,0,new_size*sizeof(T*)); 
        
        for (S i = 0; i < fFilledSize; i++) tmp[i] = At(i);
        if ( fStack ) 
                { delete [] fStack; fStack = NULL; } 
                
        fStack = tmp; fMaxSize = new_size;
}
template <typename T, typename S> PtrStack<T,S>::~PtrStack() 
{
        if ( fStack ) { Delete(); delete [] fStack; }
}
template <typename T, typename S> void PtrStack<T,S>::Delete() 
{

        if ( fStack == NULL || fFilledSize == 0 ) return; 
        
        for (S i = 0; i < fMaxSize; i++) {      
                if ( fStack[i] && fIsOwner ) delete fStack[i]; fStack[i] = NULL;   
        }
        fFilledSize = fCurrentSize = 0; 
}
}
#endif