StackOfObjects.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_StackOfObjects
#define ADF_StackOfObjects

#include "ADFConfig.h"
#include "PtrStack.h"

namespace ADF
{ 


template <typename T>
class StackOfObjects
{
private:
        PtrStack<T, UShort_t> fStack;  
                
        UShort_t fCurrentSize;     
        UShort_t fMaxSize;    
    
public:
        StackOfObjects(UShort_t max_size = 100u): 
                fStack(), fCurrentSize(0), fMaxSize(max_size) {;}    
        ~StackOfObjects()
                { fStack.Delete(); }
        

        T *New(Bool_t do_reset = true);
          

        T *At(UShort_t i) const
        { 
                if ( i < fCurrentSize ) 
                        return fStack.At(i); 
                return 0x0; 
        }    
                

        Bool_t SetSize(UShort_t how_many, Bool_t do_reset = true)
        {
                // 0 means reset the stack
                if ( how_many == 0u )
                        { fCurrentSize = 0u; return true; }
                        
                // cannot allocate so many
                if ( how_many > GetMaxSize() ) 
                        return false;
                        
                // already big enough
                if ( how_many <= GetSize() ) {
                
                        fCurrentSize = how_many;
                        
                        // call reset for the objects already in the stack
                        if ( do_reset == true ) {
                                for (UShort_t i = 0u; i < GetSize(); i++ )
                                        At(i)->Reset(); 
                        }
                        return true;
                }
                // new objects have to be added on the top
                UShort_t toadd = how_many - GetSize();
                for (UShort_t i = 0u; i < toadd; i++ ) 
                        New(do_reset);

                return how_many == GetSize();
        }       
        UShort_t GetSize() const 
                { return fCurrentSize; }
        
        UShort_t GetMaxSize() const 
                { return fMaxSize; }
                

        void Reset() 
                { fCurrentSize = 0u; }
};
template <typename T> T *StackOfObjects<T>::New(Bool_t do_reset) 
{
        T *t = NULL;
        
        if ( fCurrentSize < fStack.GetSize() ) { 
                t = fStack.At(fCurrentSize); 
                if ( do_reset )
                        t->Reset(); 
                fCurrentSize++; 
                
                return t; 
        }       
                
        if ( fCurrentSize < fMaxSize ) {
                t = new T();
                fStack.Add(t); fCurrentSize++;  
        }
        return t;
}

} // namespace ADF
#endif