ossimAppFixedTileCache Class Reference

#include <ossimAppFixedTileCache.h>

Public Types
typedef ossim_int32	ossimAppFixedCacheId

Public Member Functions
virtual	~ossimAppFixedTileCache ()
virtual void	flush ()
virtual void	flush (ossimAppFixedCacheId cacheId)
virtual void	deleteCache (ossimAppFixedCacheId cacheId)
ossimAppFixedCacheId	newTileCache (const ossimIrect &tileBoundaryRect, const ossimIpt &tileSize=ossimIpt(0, 0))
ossimAppFixedCacheId	newTileCache ()
virtual void	setRect (ossimAppFixedCacheId cacheId, const ossimIrect &boundaryTileRect)
virtual void	setTileSize (ossimAppFixedCacheId cacheId, const ossimIpt &tileSize)
ossimRefPtr< ossimImageData >	getTile (ossimAppFixedCacheId cacheId, const ossimIpt &origin)
ossimRefPtr< ossimImageData >	addTile (ossimAppFixedCacheId cacheId, ossimRefPtr< ossimImageData > data, bool duplicateData=true)
ossimRefPtr< ossimImageData >	removeTile (ossimAppFixedCacheId cacheId, const ossimIpt &origin)
void	deleteTile (ossimAppFixedCacheId cacheId, const ossimIpt &origin)
const ossimIpt &	getTileSize (ossimAppFixedCacheId cacheId)
virtual void	setMaxCacheSize (ossim_uint32 cacheSize)

Static Public Member Functions
static ossimAppFixedTileCache *	instance (ossim_uint32 maxSize=0)

Static Public Attributes
static const ossim_uint32	DEFAULT_SIZE = 1024*1024*80

Protected Member Functions
	ossimAppFixedTileCache ()
ossimFixedTileCache *	getCache (ossimAppFixedCacheId cacheId)
void	shrinkGlobalCacheSize (ossim_int32 byteCount)
void	shrinkCacheSize (ossimAppFixedCacheId id, ossim_int32 byteCount)
void	shrinkCacheSize (ossimFixedTileCache *cache, ossim_int32 byteCount)
void	deleteAll ()

Protected Attributes
ossimIpt	theTileSize
ossim_uint32	theMaxCacheSize
ossim_uint32	theMaxGlobalCacheSize
ossim_uint32	theCurrentCacheSize
std::map< ossimAppFixedCacheId, ossimFixedTileCache * >	theAppCacheMap
std::mutex	theMutex

Static Protected Attributes
static ossimAppFixedTileCache *	theInstance = 0
static ossimAppFixedCacheId	theUniqueAppIdCounter = 0

Friends
std::ostream &	operator<< (std::ostream &out, const ossimAppFixedTileCache &rhs)

Detailed Description

Definition at line 26 of file ossimAppFixedTileCache.h.

Member Typedef Documentation

ossimAppFixedCacheId

typedef ossim_int32 ossimAppFixedTileCache::ossimAppFixedCacheId

Definition at line 32 of file ossimAppFixedTileCache.h.

Constructor & Destructor Documentation

~ossimAppFixedTileCache()

ossimAppFixedTileCache::~ossimAppFixedTileCache ( )

virtual

Definition at line 101 of file ossimAppFixedTileCache.cpp.

References deleteAll().

{
   deleteAll();
}

ossimAppFixedTileCache()

ossimAppFixedTileCache::ossimAppFixedTileCache ( )

protected

Definition at line 48 of file ossimAppFixedTileCache.cpp.

Referenced by instance().

{
   if(traceDebug())
   {
      ossimNotify(ossimNotifyLevel_DEBUG) << "ossimAppFixedTileCache::ossimAppFixedTileCache() DEBUG: entered ..." << std::endl;
   }
   theInstance = this;
   theTileSize = ossimIpt(64, 64);
   theCurrentCacheSize = 0;

   // ossim::defaultTileSize(theTileSize);
   
   ossim_uint32 cacheSize = ossimString(ossimPreferences::instance()->findPreference("cache_size")).toUInt32()*(1024*1024);
   const char* tileSize = ossimPreferences::instance()->findPreference("tile_size");
   if(tileSize)
   {
      ossimString tempString(tileSize);
      std::vector<ossimString> splitString;
      tempString = tempString.trim();
      tempString.split(splitString, " ");
      if(splitString.size() > 1)
      {
         theTileSize.x = splitString[0].toInt32();
         theTileSize.y = splitString[1].toInt32();
      }
      else 
      {
         theTileSize = ossimIpt(64,64);
      }
         
    }
   if(cacheSize)
   {
      setMaxCacheSize(cacheSize);
   }
   else
   {
      setMaxCacheSize(DEFAULT_SIZE);
   }
   if(traceDebug())
   {
      ossimNotify(ossimNotifyLevel_DEBUG)
         << "DEBUG: cache tile size = " << theTileSize << std::endl
         << "Cache size = " << cacheSize << " bytes" << std::endl;
   }

   if(traceDebug())
   {
      ossimNotify(ossimNotifyLevel_DEBUG)
         << "ossimAppFixedTileCache::ossimAppFixedTileCache() DEBUG: leaving ..." << std::endl;
   }
}

Member Function Documentation

addTile()

ossimRefPtr< ossimImageData > ossimAppFixedTileCache::addTile	(	ossimAppFixedCacheId	cacheId,
		ossimRefPtr< ossimImageData >	data,
		bool	duplicateData = true
	)

Definition at line 255 of file ossimAppFixedTileCache.cpp.

References ossimFixedTileCache::addTile(), getCache(), ossimFixedTileCache::getCacheSize(), ossimImageData::getDataSizeInBytes(), shrinkCacheSize(), shrinkGlobalCacheSize(), theCurrentCacheSize, theMaxCacheSize, theMaxGlobalCacheSize, and theMutex.

Referenced by ossimCacheTileSource::fillTile(), ossimKakaduJpipHandler::getTileAtRes(), ossimGdalTileSource::getTileBlockRead(), ossimKakaduNitfReader::loadBlock(), ossimKakaduJp2Reader::loadTile(), and ossimKakaduJ2kReader::loadTile().

{
   std::lock_guard<std::mutex> lock(theMutex);
   ossimRefPtr<ossimImageData> result = 0;
   ossimFixedTileCache *aCache = this->getCache(cacheId);
   if(!aCache)
   {         
      return result;
   }
   ossim_uint32 dataSize = data->getDataSizeInBytes();

   if( (theCurrentCacheSize+dataSize) > theMaxGlobalCacheSize)
   {
      shrinkGlobalCacheSize((ossim_int32)(theMaxGlobalCacheSize*0.1));
   }

   ossim_uint32 cacheSize = 0;
   {
      cacheSize = aCache->getCacheSize();
   }
   if(cacheSize > theMaxCacheSize)
   {
//       shrinkCacheSize(aCache,
//                       (ossim_int32)(aCache->getCacheSize()*.1));
      shrinkCacheSize(aCache,
                      (ossim_int32)(1024*1024));
   }
   {
      cacheSize = aCache->getCacheSize();
      result    = aCache->addTile(data, duplicateData);
   
      theCurrentCacheSize += (aCache->getCacheSize() - cacheSize);
   }
   
   return result;
}

deleteAll()

void ossimAppFixedTileCache::deleteAll ( )

protected

Definition at line 295 of file ossimAppFixedTileCache.cpp.

References theAppCacheMap, theCurrentCacheSize, and theMutex.

Referenced by ~ossimAppFixedTileCache().

{
   std::lock_guard<std::mutex> lock(theMutex);
   theCurrentCacheSize = 0;
   theAppCacheMap.clear();
}

deleteCache()

void ossimAppFixedTileCache::deleteCache ( ossimAppFixedCacheId  cacheId )

virtual

Definition at line 153 of file ossimAppFixedTileCache.cpp.

References getCache(), ossimFixedTileCache::getCacheSize(), theAppCacheMap, theCurrentCacheSize, theMutex, and ossimRefPtr< T >::valid().

Referenced by ossimJpegTileSource::allocate(), ossimPngReader::allocate(), ossimNitfTileSource::allocate(), ossimKakaduJp2Reader::closeEntry(), ossimKakaduJ2kReader::closeEntry(), ossimCacheTileSource::deleteRlevelCache(), ossimKakaduJpipHandler::deleteRlevelCache(), ossimGdalTileSource::deleteRlevelCache(), ossimJpegTileSource::destroy(), ossimPngReader::destroy(), ossimNitfTileSource::destroy(), and ossimNitfTileSource::setCacheEnabledFlag().

{
   std::lock_guard<std::mutex> lock(theMutex);
   ossimRefPtr<ossimFixedTileCache> cache = getCache(cacheId);
   {
      std::map<ossimAppFixedCacheId, ossimFixedTileCache*>::iterator iter = theAppCacheMap.find(cacheId);
      
      if(cache.valid())
      {
         theAppCacheMap.erase(iter);
         theCurrentCacheSize -= cache->getCacheSize();
      }
      cache = 0;
   }
}

deleteTile()

void ossimAppFixedTileCache::deleteTile	(	ossimAppFixedCacheId	cacheId,
		const ossimIpt &	origin
	)

Definition at line 320 of file ossimAppFixedTileCache.cpp.

References ossimFixedTileCache::deleteTile(), getCache(), ossimFixedTileCache::getCacheSize(), theCurrentCacheSize, and theMutex.

{
   std::lock_guard<std::mutex> lock(theMutex);
   ossimFixedTileCache* cache = getCache(cacheId);
   if(cache)
   {
      ossim_uint32 cacheSize = cache->getCacheSize();
      cache->deleteTile(origin);
      theCurrentCacheSize += (cache->getCacheSize() - cacheSize);
   }
}

flush() [1/2]

void ossimAppFixedTileCache::flush ( )

virtual

Will flush all cache registered

Definition at line 127 of file ossimAppFixedTileCache.cpp.

References theAppCacheMap, theCurrentCacheSize, and theMutex.

Referenced by ossimCacheTileSource::flush(), ossimKakaduJpipHandler::flushCache(), and shrinkGlobalCacheSize().

{
   std::lock_guard<std::mutex> lock(theMutex);
   std::map<ossimAppFixedCacheId, ossimFixedTileCache*>::iterator currentIter = theAppCacheMap.begin();
   
   while(currentIter != theAppCacheMap.end())
   {
      (*currentIter).second->flush();
      ++currentIter;
   }
   theCurrentCacheSize = 0;
}

flush() [2/2]

void ossimAppFixedTileCache::flush ( ossimAppFixedCacheId  cacheId )

virtual

Definition at line 140 of file ossimAppFixedTileCache.cpp.

References ossimFixedTileCache::flush(), getCache(), ossimFixedTileCache::getCacheSize(), theCurrentCacheSize, and theMutex.

{
   std::lock_guard<std::mutex> lock(theMutex);
   ossimFixedTileCache* cache = getCache(cacheId);
   {
      if(cache)
      {
         theCurrentCacheSize -= cache->getCacheSize();
         cache->flush();
      }
   }
}

getCache()

ossimFixedTileCache * ossimAppFixedTileCache::getCache ( ossimAppFixedCacheId  cacheId )

protected

Definition at line 333 of file ossimAppFixedTileCache.cpp.

References theAppCacheMap.

Referenced by addTile(), deleteCache(), deleteTile(), flush(), getTile(), getTileSize(), removeTile(), setRect(), setTileSize(), shrinkCacheSize(), and shrinkGlobalCacheSize().

{   
   std::map<ossimAppFixedCacheId, ossimFixedTileCache*>::const_iterator
      currentIter = theAppCacheMap.find(cacheId);
   ossimFixedTileCache* result = 0;
   
   if(currentIter != theAppCacheMap.end())
   {
      result = (*currentIter).second;
   }

   return result;
}

getTile()

ossimRefPtr< ossimImageData > ossimAppFixedTileCache::getTile	(	ossimAppFixedCacheId	cacheId,
		const ossimIpt &	origin
	)

Definition at line 239 of file ossimAppFixedTileCache.cpp.

References getCache(), ossimFixedTileCache::getTile(), and theMutex.

Referenced by ossimCacheTileSource::fillTile(), ossimKakaduJpipHandler::getTileAtRes(), ossimGdalTileSource::getTileBlockRead(), ossimNitfTileSource::loadBlockFromCache(), ossimKakaduJp2Reader::loadTileFromCache(), and ossimKakaduJ2kReader::loadTileFromCache().

{
   std::lock_guard<std::mutex> lock(theMutex);
   ossimRefPtr<ossimImageData> result = 0;
   ossimFixedTileCache* cache = getCache(cacheId);
   if(cache)
   {
      result = cache->getTile(origin);
   }

   return result;
}

getTileSize()

const ossimIpt & ossimAppFixedTileCache::getTileSize

(

ossimAppFixedCacheId

cacheId

)

Definition at line 420 of file ossimAppFixedTileCache.cpp.

References getCache(), ossimFixedTileCache::getTileSize(), theMutex, and theTileSize.

Referenced by ossimCacheTileSource::fillTile().

{
   std::lock_guard<std::mutex> lock(theMutex);
   ossimFixedTileCache* cache = getCache(cacheId);
   if(cache)
   {
      return cache->getTileSize();
   }
   return theTileSize;
}

instance()

ossimAppFixedTileCache * ossimAppFixedTileCache::instance ( ossim_uint32  maxSize = 0 )

static

Definition at line 106 of file ossimAppFixedTileCache.cpp.

References ossimAppFixedTileCache(), setMaxCacheSize(), and theInstance.

Referenced by ossimJpegTileSource::allocate(), ossimPngReader::allocate(), ossimNitfTileSource::allocate(), ossimNitfTileSource::allocateBuffers(), ossimKakaduJp2Reader::closeEntry(), ossimKakaduJ2kReader::closeEntry(), ossimCacheTileSource::deleteRlevelCache(), ossimKakaduJpipHandler::deleteRlevelCache(), ossimGdalTileSource::deleteRlevelCache(), ossimJpegTileSource::destroy(), ossimPngReader::destroy(), ossimNitfTileSource::destroy(), ossimCacheTileSource::fillTile(), ossimCacheTileSource::flush(), ossimKakaduJpipHandler::flushCache(), ossimCacheTileSource::getCacheId(), ossimKakaduJpipHandler::getTileAtRes(), ossimGdalTileSource::getTileBlockRead(), ossimKakaduJpipHandler::initializeRlevelCache(), ossimKakaduNitfReader::loadBlock(), ossimNitfTileSource::loadBlockFromCache(), ossimKakaduJp2Reader::loadTile(), ossimKakaduJ2kReader::loadTile(), ossimKakaduJp2Reader::loadTileFromCache(), ossimKakaduJ2kReader::loadTileFromCache(), ossimKakaduJpipHandler::performRlevelSetup(), ossimNitfTileSource::setCacheEnabledFlag(), and ossimGdalTileSource::setRlevelCache().

{
   if(!theInstance)
   {
      theInstance = new ossimAppFixedTileCache;
      if(maxSize)
    {
      theInstance->setMaxCacheSize(maxSize);
    }
   }
   return theInstance;
}

newTileCache() [1/2]

ossimAppFixedTileCache::ossimAppFixedCacheId ossimAppFixedTileCache::newTileCache	(	const ossimIrect &	tileBoundaryRect,
		const ossimIpt &	tileSize = ossimIpt(0,0)
	)

Will create a new Tile cache for this application if the tile size is 0,0 it will use the default tile size. Will return 0 if not successful.

Definition at line 169 of file ossimAppFixedTileCache.cpp.

References ossimFixedTileCache::getTileSize(), ossimFixedTileCache::setRect(), theAppCacheMap, theMutex, theUniqueAppIdCounter, ossimIpt::x, and ossimIpt::y.

Referenced by ossimJpegTileSource::allocate(), ossimCacheTileSource::getCacheId(), and ossimGdalTileSource::setRlevelCache().

{
   std::lock_guard<std::mutex> lock(theMutex);
   ossimAppFixedCacheId result = -1; 
   ossimFixedTileCache* newCache = new ossimFixedTileCache;
   if(tileSize.x == 0 ||
      tileSize.y == 0)
   {
      // newCache->setRect(tileBoundaryRect, theTileSize);
      newCache->setRect(tileBoundaryRect,
                        newCache->getTileSize());
   }
   else
   {
      newCache->setRect(tileBoundaryRect, tileSize);
   }
   result = theUniqueAppIdCounter;
   theAppCacheMap.insert(std::make_pair(result, newCache));
   ++theUniqueAppIdCounter;
   
   return result;
}

newTileCache() [2/2]

ossimAppFixedTileCache::ossimAppFixedCacheId ossimAppFixedTileCache::newTileCache

(

)

Definition at line 193 of file ossimAppFixedTileCache.cpp.

References theAppCacheMap, theMutex, and theUniqueAppIdCounter.

{
   std::lock_guard<std::mutex> lock(theMutex);
   ossimAppFixedCacheId result = -1;
   ossimFixedTileCache* newCache = new ossimFixedTileCache;
   
   {
      result = theUniqueAppIdCounter;
      theAppCacheMap.insert(std::make_pair(result, newCache));
      ++theUniqueAppIdCounter;
   }
   
   return result;
   
}

removeTile()

ossimRefPtr< ossimImageData > ossimAppFixedTileCache::removeTile	(	ossimAppFixedCacheId	cacheId,
		const ossimIpt &	origin
	)

Definition at line 302 of file ossimAppFixedTileCache.cpp.

References getCache(), ossimFixedTileCache::getCacheSize(), ossimFixedTileCache::removeTile(), theCurrentCacheSize, and theMutex.

{
   std::lock_guard<std::mutex> lock(theMutex);
   ossimRefPtr<ossimImageData> result = 0;
   
   ossimFixedTileCache* cache = getCache(cacheId);
   if(cache)
   {
      ossim_uint32 cacheSize = cache->getCacheSize();
      result = cache->removeTile(origin);
      theCurrentCacheSize += (cache->getCacheSize() - cacheSize);
   }

   return result;
}

setMaxCacheSize()

void ossimAppFixedTileCache::setMaxCacheSize ( ossim_uint32  cacheSize )

virtual

Definition at line 119 of file ossimAppFixedTileCache.cpp.

References theMaxCacheSize, theMaxGlobalCacheSize, and theMutex.

Referenced by instance().

{
   std::lock_guard<std::mutex> lock(theMutex);
   theMaxGlobalCacheSize = cacheSize;
   theMaxCacheSize = cacheSize;
   //   theMaxCacheSize      = (ossim_uint32)(theMaxGlobalCacheSize*.2);
}

setRect()

void ossimAppFixedTileCache::setRect ( ossimAppFixedCacheId  cacheId, const ossimIrect &  boundaryTileRect  )

virtual

Definition at line 209 of file ossimAppFixedTileCache.cpp.

References getCache(), ossimFixedTileCache::getCacheSize(), ossimFixedTileCache::getTileSize(), ossimFixedTileCache::setRect(), theCurrentCacheSize, and theMutex.

{
   std::lock_guard<std::mutex> lock(theMutex);
   ossimFixedTileCache* cache = getCache(cacheId);
   if(cache)
   {
      
      ossim_uint32 cacheSize = cache->getCacheSize();
      // cache->setRect(boundaryTileRect, theTileSize);
      cache->setRect(boundaryTileRect,
                     cache->getTileSize());      
      theCurrentCacheSize += (cache->getCacheSize() - cacheSize);
   }
}

setTileSize()

void ossimAppFixedTileCache::setTileSize ( ossimAppFixedCacheId  cacheId, const ossimIpt &  tileSize  )

virtual

Definition at line 225 of file ossimAppFixedTileCache.cpp.

References getCache(), ossimFixedTileCache::getCacheSize(), ossimFixedTileCache::getTileBoundaryRect(), ossimFixedTileCache::getTileSize(), ossimFixedTileCache::setRect(), theCurrentCacheSize, theMutex, and theTileSize.

{
   std::lock_guard<std::mutex> lock(theMutex);
   ossimFixedTileCache* cache = getCache(cacheId);
   if(cache)
   {
      ossim_uint32 cacheSize = cache->getCacheSize();
      cache->setRect(cache->getTileBoundaryRect(), tileSize);
      theCurrentCacheSize += (cache->getCacheSize() - cacheSize);
      theTileSize = cache->getTileSize();
   }
}

shrinkCacheSize() [1/2]

void ossimAppFixedTileCache::shrinkCacheSize ( ossimAppFixedCacheId  id, ossim_int32  byteCount  )

protected

Definition at line 377 of file ossimAppFixedTileCache.cpp.

References getCache().

Referenced by addTile().

{
   ossimFixedTileCache* cache = getCache(id);

   if(cache)
   {
      shrinkCacheSize(cache, byteCount);
   }
}

shrinkCacheSize() [2/2]

void ossimAppFixedTileCache::shrinkCacheSize ( ossimFixedTileCache *  cache, ossim_int32  byteCount  )

protected

Definition at line 388 of file ossimAppFixedTileCache.cpp.

References abs, ossimFixedTileCache::deleteTile(), ossimFixedTileCache::flush(), ossimFixedTileCache::getCacheSize(), and theCurrentCacheSize.

{
   if(cache)
   {
      ossim_int32 cacheSize = cache->getCacheSize();
      if(cacheSize <= byteCount)
      {
         cache->flush();
      }
      else
      {
         while(byteCount > 0)
         {
            ossim_uint32 before = cache->getCacheSize();
            cache->deleteTile();
            ossim_uint32 after = cache->getCacheSize();
            ossim_uint32 delta = std::abs((int)(before - after));
            if(delta)
            {
               byteCount -= delta;
               theCurrentCacheSize -= (delta);
            }
            else
            {
               byteCount = 0;
            }
         }
      }
   }
}

shrinkGlobalCacheSize()

void ossimAppFixedTileCache::shrinkGlobalCacheSize ( ossim_int32  byteCount )

protected

Definition at line 348 of file ossimAppFixedTileCache.cpp.

References ossimFixedTileCache::deleteTile(), flush(), getCache(), ossimFixedTileCache::getCacheSize(), theAppCacheMap, and theCurrentCacheSize.

Referenced by addTile().

{
   if(static_cast<ossim_uint32>(byteCount) >= theCurrentCacheSize)
   {
      flush();
   }
   else
   {
      while(byteCount > 0)
      {
         std::map<ossimAppFixedCacheId, ossimFixedTileCache*>::iterator iter = theAppCacheMap.begin();
         while( (iter != theAppCacheMap.end())&&(byteCount>0))
         {
            ossimFixedTileCache* cache = getCache((*iter).first);
            if(cache)
            {
               ossim_uint32 before = cache->getCacheSize();
               cache->deleteTile();
               ossim_uint32 after = cache->getCacheSize();
               ossim_uint32 delta = (before - after);
               byteCount -= delta;
               theCurrentCacheSize -= (delta);
            }
            ++iter;
         }
      }
   }
}

Friends And Related Function Documentation

operator<<

std::ostream& operator<< ( std::ostream &  out, const ossimAppFixedTileCache &  rhs  )

friend

Definition at line 26 of file ossimAppFixedTileCache.cpp.

{
   std::map<ossimAppFixedTileCache::ossimAppFixedCacheId, ossimFixedTileCache*>::const_iterator iter = rhs.theAppCacheMap.begin();

   if(iter == rhs.theAppCacheMap.end())
   {
      ossimNotify(ossimNotifyLevel_NOTICE)
         << "***** APP CACHE EMPTY *****" << endl;
   }
   else
   {
      while(iter != rhs.theAppCacheMap.end())
      {
         out << "Cache id = "<< (*iter).first << " size = " << (*iter).second->getCacheSize() << endl;
         ++iter;
      }
   }

   return out;
}

Member Data Documentation

DEFAULT_SIZE

const ossim_uint32 ossimAppFixedTileCache::DEFAULT_SIZE = 1024*1024*80

static

Definition at line 31 of file ossimAppFixedTileCache.h.

theAppCacheMap

std::map<ossimAppFixedCacheId, ossimFixedTileCache*> ossimAppFixedTileCache::theAppCacheMap

protected

Definition at line 112 of file ossimAppFixedTileCache.h.

Referenced by deleteAll(), deleteCache(), flush(), getCache(), newTileCache(), operator<<(), and shrinkGlobalCacheSize().

theCurrentCacheSize

ossim_uint32 ossimAppFixedTileCache::theCurrentCacheSize

protected

Definition at line 110 of file ossimAppFixedTileCache.h.

Referenced by addTile(), deleteAll(), deleteCache(), deleteTile(), flush(), removeTile(), setRect(), setTileSize(), shrinkCacheSize(), and shrinkGlobalCacheSize().

theInstance

ossimAppFixedTileCache * ossimAppFixedTileCache::theInstance = 0

staticprotected

Definition at line 101 of file ossimAppFixedTileCache.h.

Referenced by instance().

theMaxCacheSize

ossim_uint32 ossimAppFixedTileCache::theMaxCacheSize

protected

Definition at line 108 of file ossimAppFixedTileCache.h.

Referenced by addTile(), and setMaxCacheSize().

theMaxGlobalCacheSize

ossim_uint32 ossimAppFixedTileCache::theMaxGlobalCacheSize

protected

Definition at line 109 of file ossimAppFixedTileCache.h.

Referenced by addTile(), and setMaxCacheSize().

theMutex

std::mutex ossimAppFixedTileCache::theMutex

protected

Definition at line 114 of file ossimAppFixedTileCache.h.

Referenced by addTile(), deleteAll(), deleteCache(), deleteTile(), flush(), getTile(), getTileSize(), newTileCache(), removeTile(), setMaxCacheSize(), setRect(), and setTileSize().

theTileSize

ossimIpt ossimAppFixedTileCache::theTileSize

protected

Definition at line 107 of file ossimAppFixedTileCache.h.

Referenced by getTileSize(), and setTileSize().

theUniqueAppIdCounter

ossimAppFixedTileCache::ossimAppFixedCacheId ossimAppFixedTileCache::theUniqueAppIdCounter = 0

staticprotected

Will hold the current unique Application id.

Definition at line 106 of file ossimAppFixedTileCache.h.

Referenced by newTileCache().

---

The documentation for this class was generated from the following files:

• ossimAppFixedTileCache.h
• ossimAppFixedTileCache.cpp