PersistentCache.h

Go to the documentation of this file.

#ifndef PERSISTENT_CACHE_H
#define PERSISTENT_CACHE_H

#include <vrecko/Export>
#include <vrecko/MTLock.h>
#include <helpers/DynamicArray.h>
#include <helpers/BufFile.h>

#include <osg/Node>



namespace vrecko {


class EnvironmentObject;


class VRECKO_EXPORT PersistentCache {
public:

    class OpenedCacheFile {
        friend PersistentCache;
    public:
        OpenedCacheFile();
        ~OpenedCacheFile();

        inline const std::string& getTranslatedFileName() { return translatedFileName; }
        inline const std::string& getCachedFileName() { return cachedFileName; }

    protected:
        std::string translatedFileName;

        std::string cachedFileName;

        int iReaders, iWaitingWriters, iWriters;
    };


    PersistentCache();
    ~PersistentCache();

    void setEnable(bool bNewEnableCache);

    inline bool getEnable() { return bEnableCache; }

    const char* getCacheDir() { return cacheDir; }

    osg::Node* loadModel(const char *relatedFileName, vrecko::EnvironmentObject *obj);
        
    bool saveModel(const char *relatedFileName, osg::Node *node, vrecko::EnvironmentObject *obj);
        
    inline bool openCacheFileForReading(const char *dataName, const char *relatedFileName, unsigned long version,
        OpenedCacheFile** cacheData, vrecko::BufferedFile **bfile, unsigned long ulWaitTimeout = 0)
        { return internalOpenReadWrite(dataName, relatedFileName, version, cacheData, bfile, NULL, ulWaitTimeout); }
        
    void closeCacheFile(OpenedCacheFile* cacheData, vrecko::BufferedFile *bfile);
        
    inline bool openCacheFileForWriting(const char *dataName, const char *relatedFileName, unsigned long version,
        OpenedCacheFile** cacheData, vrecko::BufferedFileWrite **bfile, unsigned long ulWaitTimeout = 0)
        { return internalOpenReadWrite(dataName, relatedFileName, version, cacheData, NULL, bfile, ulWaitTimeout); }

    void closeCacheFile(OpenedCacheFile* cacheData, vrecko::BufferedFileWrite *bfile);
        

protected:

    bool bEnableCache;

    DynamicArray<OpenedCacheFile*> openedFiles;
        
    MTLock filesLock;

    CHAR baseDir[1000];

    CHAR cacheDir[1000];

    void translateName(char *outTranslatedName, const char *inDataName, const char *inRelatedFileName);
        


    //bool isInCache(const char *dataName, const char *relatedFileName, char *outFullCachedFileName = NULL);
        // Check whether a specified file/data is in the cache.
        // The REAL file MUST exist - its time stamp is taken into account when checking the validity
        // of the cached version (if the cached version is stored on the disk).

    int internalFindAndLock(const char *originalFileName, const char *translatedFileName, unsigned long version,
        const char* desiredExtension, bool bReading, unsigned long ulWaitTimeout);

    bool internalOpenReadWrite(const char *dataName, const char *relatedFileName, unsigned long version,
        OpenedCacheFile** cacheData, vrecko::BufferedFile **bfile, vrecko::BufferedFileWrite **bfileWrite, unsigned long ulWaitTimeout);

    void internalDecrementReaderWriter(OpenedCacheFile* cacheData, bool bReading);

    bool testVersionIsAtLeast(const char *fileName, int minVersion);

    void constructModelDataName(char *outDataName, vrecko::EnvironmentObject* obj);
};


}; // namespace vrecko

#endif