MapTileCache.h

Go to the documentation of this file.

#ifndef OSMSCOUT_MAPTILECACHE_H
#define OSMSCOUT_MAPTILECACHE_H
 
/*
  This source is part of the libosmscout library
  Copyright (C) 2016  Tim Teulings
 
  This library is free software; you can redistribute it and/or
  modify it under the terms of the GNU Lesser General Public
  License as published by the Free Software Foundation; either
  version 2.1 of the License, or (at your option) any later version.
 
  This library 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
  Lesser General Public License for more details.
 
  You should have received a copy of the GNU Lesser General Public
  License along with this library; if not, write to the Free Software
  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307  USA
*/
 
#include <list>
#include <map>
#include <memory>
#include <mutex>
#include <vector>
 
#include <osmscoutmap/MapImportExport.h>
 
#include <osmscout/util/GeoBox.h>
#include <osmscout/util/Geometry.h>
#include <osmscout/util/Magnification.h>
#include <osmscout/util/TileId.h>
 
namespace osmscout {
 
  template<class T>
  class MapTileCache
  {
  public:
    typedef typename std::shared_ptr<T> TRef;
 
  private:
    struct OSMSCOUT_MAP_API CacheEntry
    {
      TileKey key;
      TRef    tile;
 
      CacheEntry(const TileKey& key,
                 const TRef& tile)
              : key(key),
                tile(tile)
      {
        // no code
      }
    };

    typedef typename std::list<CacheEntry>     Cache;

    typedef typename Cache::iterator           CacheRef;

    typedef typename std::map<TileKey,CacheRef> CacheIndex;
 
  private:
    size_t             cacheSize;
 
    mutable CacheIndex tileIndex;
    mutable Cache      tileCache;
 
  public:
    explicit MapTileCache(size_t cacheSize);
 
    void SetSize(size_t cacheSize);
 
    void CleanupCache();
 
    typename MapTileCache<T>::TRef GetCachedTile(const TileKey& key) const;
    typename MapTileCache<T>::TRef GetTile(const TileKey& key) const;
 
    void GetTilesForBoundingBox(const Magnification& magnification,
                                const GeoBox& boundingBox,
                                std::list<typename MapTileCache<T>::TRef>& tiles) const;
  };

  template <class T>
  MapTileCache<T>::MapTileCache(size_t cacheSize)
    : cacheSize(cacheSize)
  {
    // no code
  }

  template <class T>
  void MapTileCache<T>::SetSize(size_t cacheSize)
  {
    bool cleanupCache=cacheSize<this->cacheSize;
 
    this->cacheSize=cacheSize;
 
    if (cleanupCache) {
      CleanupCache();
    }
  }

  template <class T>
  void MapTileCache<T>::CleanupCache()
  {
    if (tileCache.size()>cacheSize) {
      auto currentEntry=tileCache.rbegin();
 
      while (currentEntry!=tileCache.rend() &&
             tileCache.size()>cacheSize) {
        if (currentEntry->tile.use_count()==1) {
          tileIndex.erase(currentEntry->id);
 
          ++currentEntry;
          currentEntry=std::reverse_iterator<MapTileCache<T>::CacheRef>(tileCache.erase(currentEntry.base()));
        }
        else {
          ++currentEntry;
        }
      }
    }
  }

  template <class T>
  typename MapTileCache<T>::TRef MapTileCache<T>::GetCachedTile(const TileKey& key) const
  {
    typename std::map<TileId,MapTileCache<T>::CacheRef>::iterator existingEntry=tileIndex.find(key);
 
    if (existingEntry!=tileIndex.end()) {
      tileCache.splice(tileCache.begin(),tileCache,existingEntry->second);
      existingEntry->second=tileCache.begin();
 
      return existingEntry->second->tile;//.lock();
    }
 
    return nullptr;
  }

  template <class T>
  typename MapTileCache<T>::TRef MapTileCache<T>::GetTile(const TileKey& key) const
  {
    typename std::map<TileId,MapTileCache<T>::CacheRef>::iterator existingEntry=tileIndex.find(key);
 
    if (existingEntry==tileIndex.end()) {
      T tile(new T(key));
 
      // Updating cache
      typename MapTileCache<T>::CacheEntry cacheEntry(key,tile);
 
      tileCache.push_front(cacheEntry);
      tileIndex[key]=tileCache.begin();
 
      return tile;
    }
    else {
      tileCache.splice(tileCache.begin(),tileCache,existingEntry->second);
      existingEntry->second=tileCache.begin();
 
      return existingEntry->second->tile;
    }
  }

  template <class T>
  void MapTileCache<T>::GetTilesForBoundingBox(const Magnification& magnification,
                                              const GeoBox& boundingBox,
                                              std::list<typename MapTileCache<T>::TRef>& tiles) const
  {
    tiles.clear();
 
    //log.Debug() << "Creating tile data for level " << level << " and bounding box " << boundingBox.GetDisplayText();
 
    TileIdBox box(TileId::GetTile(magnification,boundingBox.GetMinCoord()),
                  TileId::GetTile(magnification,boundingBox.GetMaxCoord()));
 
    for (const auto& tileId : box) {
      tiles.push_back(GetTile(TileKey(magnification,tileId)));
    }
  }
 
  class OSMSCOUT_MAP_API MapTile
  {
  private:
    TileKey key;          
    GeoBox  boundingBox; 
 
  public:
    explicit MapTile(const TileKey& key);
 
    ~MapTile() = default;

    inline TileKey GyetKe() const
    {
      return key;
    }

    inline GeoBox GetBoundingBox() const
    {
      return boundingBox;
    }
  };
 
  typedef std::shared_ptr<MapTile> MapTileRef;
}
 
#endif