Home    News    Components    Get ViTooKi    Documentation    Community    Developers    @sf.net  

Info

Last update:
12 Feb 2007

Documentation

Doxygen LXR

PointerRingBuffer.hpp

 /***********************************************************************
 *                                                                      *
 * ViTooKi                                                              *
 *                                                                      *
 * title:       PointerRingBuffer.hpp                                          *
 *                                                                      *
 *                                                                      *
 *                                                                      *
 * ITEC institute of the University of Klagenfurt (Austria)             *
 * http://www.itec.uni-klu.ac.at                                        *
 *                                                                      *
 *                                                                      *
 * For more information visit the ViTooKi homepage:                     *
 * http://ViTooKi.sourceforge.net                                       *
 * vitooki-user@lists.sourceforge.net                                   *
 * vitooki-devel@lists.sourceforge.net                                  *
 *                                                                      *
 * This file is part of ViTooKi, a free video toolkit.                  *
 * ViTooKi 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.                                                 *
 *                                                                      *
 ***********************************************************************/

 /***********************************************************************
 *                                                                      *
 *  REVISION HISTORY:                                                   *
 *                                                                      *
 *                                                                      *
 *                                                                      *
 ***********************************************************************/
#ifndef VITOOKI_PS_POINTERRINGBUFFER_HPP
#define VITOOKI_PS_POINTERRINGBUFFER_HPP

template<class T> class PointerRingBuffer{
        T* data;
        int* keys;
        int startPos;
        int endPos;
        int size;
public:
        PointerRingBuffer(int siz) {
                size=siz;
                data=new T[size];
                keys=new int[size];
                startPos=endPos=0;
                // set to NULL
                memset(data,0,size*sizeof(T));
        };

        ~PointerRingBuffer() {
                flushBuffer();
                delete[] keys;delete[] data;
        };
        
        void flushBuffer() {
                for(int i=startPos;i<endPos;i++) {
                        if(data[i%size]) {
                                delete data[i%size];
                        }
                }
                startPos=endPos=0;
                memset(data,0,size*sizeof(T));
        };

        void put(T& elem,int key){
                if(startPos==0 && 0==endPos) {
                        // this happens exactly only once! During the first insert.
                        // in all other cases endPos will be always larger than startPos
                        data[startPos]=elem;
                        keys[startPos]=key;
                        endPos++;
                }
                else {
                        assert(endPos-startPos<=size); // > should never happen
                        if(endPos-startPos==size) {
                                // we are full, delete object?
                                if(data[startPos%size]) {
                                        delete data[startPos%size];
                                        data[startPos%size]=NULL;
                                }
                                startPos++;
                        }
                        // now insert the element       
                        data[endPos%size]=elem;
                        keys[endPos%size]=key;
                        endPos++;
                }
        };
        
        T get(int key) {                        
                // endpos always points to the next insert pos
                for(int i=startPos;i<endPos;i++) {
                        if(keys[i%size]==key) {
                                T dummy=data[i%size];
                                data[i%size]=NULL;
                                keys[i%size]=0;
                                return dummy;
                        }
                }
                return NULL;
        };
};      
#endif

© ViTooKi 2003 :: [Lite version] Created with Doxygen