Cache.h

Go to the documentation of this file.

#ifndef GlobeEngine_Cache_h
#define GlobeEngine_Cache_h

#include "OpenGL_Includes.h"
#include <stdio.h>
#include <memory>
#include <vector>

namespace geSpatial {
    
    template <class T> class Cache
    {
    public:
        Cache()
        {
            capacity = 0;
            clear();
        }
        
        ~Cache()
        {
            deleteFrontbuffer();
            deleteBackbuffer();
            capacity = 0;
        }
        
        void clear()
        {
            deleteFrontbuffer();
            deleteBackbuffer();
            cacheIndex = 0;
            capacity = 0;
        }
        
        void create(int _capacity)
        {
            setCapacity(_capacity);
        }
        
        void swap()
        {
            deleteFrontbuffer();
            frontbuffer = backbuffer;
            //backbuffer = new T[capacity];
            deleteBackbuffer();
            allocateBackbuffer();
        }
        
        std::shared_ptr<T> requestCacheWritePointer()
        //T* requestCacheWritePointer()
        {
            unsigned int res = cacheIndex;
            cacheIndex++;
            //return &backbuffer[res];
            return backbuffer[res];
        }
        
        const std::vector< std::shared_ptr<T> >& getFrontBuffer()
        //T* getFrontBuffer()
        {
            return frontbuffer;
        }
        
        void setCapacity(unsigned int _capacity)
        {
            clear();
            capacity = _capacity;
            allocateCache();
        }
        
        int getObjectCount(){
            return cacheIndex;
        }
        
    private:
        void allocateCache() {
            for (int i=0;i<capacity;i++) {
                std::shared_ptr<T> frontTile = std::make_shared<T>();
                frontbuffer.push_back(frontTile);
            }
            allocateBackbuffer();
            //frontbuffer = new T[capacity];
            //backbuffer = new T[capacity];
        }
        
        void allocateBackbuffer() {
            for (int i=0;i<capacity;i++) {
                std::shared_ptr<T> backTile = std::make_shared<T>();
                backbuffer.push_back(backTile);
            }
        }
        
        void deleteFrontbuffer() { 
            /*if (this->frontbuffer != NULL) {
                delete [] this->frontbuffer;
                this->frontbuffer = NULL;
            }*/
            if (this->frontbuffer.size() != 0) {
                this->frontbuffer.clear();
            }
        } 
        
        void deleteBackbuffer() { 
//            if (backbuffer != NULL) { 
//                delete [] backbuffer; 
//                backbuffer = NULL; 
//            }
            if (this->backbuffer.size() != 0) {
                this->backbuffer.clear();
            }
        }
        
        std::vector< std::shared_ptr<T> > frontbuffer;
        std::vector< std::shared_ptr<T> > backbuffer;
        //T* frontbuffer;
        //T* backbuffer;
        unsigned int cacheIndex;
        unsigned int capacity;
    };
}
#endif