prepare for 1.1.6pre2

[lyx.git] / src / graphics / GraphicsCache.C

diff --git a/src/graphics/GraphicsCache.C b/src/graphics/GraphicsCache.C
index 1721b0c6f38835ca056c95da816d4b7daf9d77be..af2233cfb8784e4206a9caee5ede1de3e0256251 100644 (file)
--- a/src/graphics/GraphicsCache.C
+++ b/src/graphics/GraphicsCache.C
@@ -17,6 +17,7 @@
 
 #include "GraphicsCache.h"
 
+#include "support/LAssert.h"
 
 GraphicsCache * GraphicsCache::singleton = 0;
 
@@ -24,40 +25,59 @@ GraphicsCache * GraphicsCache::singleton = 0;
 GraphicsCache * 
 GraphicsCache::getInstance()
 {
-    if (! singleton) {
-        singleton = new GraphicsCache;
-    }
+       if (!singleton) {
+               singleton = new GraphicsCache;
+               Assert(singleton != 0);
+       }
 
-    return singleton;
+       return singleton;
 }
 
 
 GraphicsCache::~GraphicsCache()
 {
-        delete singleton;
+       // Free the map.
+       //std::foreach(map.begin(), map.end(), ...);
+//#warning This is a bogus reason to not clean up after your self. (Lgb)
+       // TODO: Clean up here (BE)
+       
+       // This is not really needed, it will only happen on program close and in
+       // any case the OS will release those resources (not doing it may have 
+       // a good effect on closing time).
+       
+       delete singleton;
 }
 
 
-GraphicsCacheItem * 
+GraphicsCacheItem *
 GraphicsCache::addFile(string const & filename)
 {
-    CacheType::const_iterator it = cache.find(filename);
-    
-    if (it != cache.end()) {
-        return (*it).second;
-    }
-    // INCOMPLETE!
-    return 0;
+       CacheType::iterator it = cache.find(filename);
+       
+       if (it != cache.end()) {
+               return new GraphicsCacheItem( *((*it).second) );
+       }
+       
+       GraphicsCacheItem * cacheItem = new GraphicsCacheItem();
+       if (cacheItem == 0)
+               return 0;
+       
+       cacheItem->setFilename(filename);
+       
+       cache[filename] = cacheItem;
+       
+       // We do not want to return the main cache object, otherwise when the
+       // will destroy their copy they will destroy the main copy.
+       return new GraphicsCacheItem( *cacheItem );
 }
 
 
 void
 GraphicsCache::removeFile(string const & filename)
 {
-    CacheType::const_iterator it = cache.find(filename);
-    
-    if (it != cache.end()) {
-        // INCOMPLETE!
-//        cache.erase(it);
-    }
+       // We do not destroy the GraphicsCacheItem since we are here because
+       // the last copy of it is being erased.
+
+       if (cache.find(filename) != cache.end())
+               cache.erase(filename);
 }