DataTileCache.h

Go to the documentation of this file.

#ifndef OSMSCOUT_TILEDDATACACHE_H
#define OSMSCOUT_TILEDDATACACHE_H
 
/*
  This source is part of the libosmscout library
  Copyright (C) 2015  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 <functional>
#include <map>
#include <memory>
#include <mutex>
#include <vector>
 
#include <osmscoutmap/MapImportExport.h>
 
#include <osmscout/Node.h>
#include <osmscout/Way.h>
#include <osmscout/Area.h>
#include <osmscout/Route.h>
 
#include <osmscout/TypeInfoSet.h>
 
#include <osmscout/util/GeoBox.h>
#include <osmscout/util/Magnification.h>
#include <osmscout/util/TileId.h>
 
#include <osmscout/system/Assert.h>
 
namespace osmscout {

  template<typename O>
  class OSMSCOUT_MAP_API TileData
  {
  private:
    mutable std::mutex mutex;
 
    TypeInfoSet        types;
 
    std::vector<O>     prefillData;
    std::vector<O>     data;
 
    bool               complete=false;
 
  public:
    TileData() = default;
 
    bool IsEmpty() const
    {
      std::scoped_lock<std::mutex> guard(mutex);
 
      return types.Empty();
    }

    void Invalidate()
    {
      std::scoped_lock<std::mutex> guard(mutex);
 
      complete=false;
    }

    void AddPrefillData(const TypeInfoSet& types,
                        const std::vector<O>& data)
    {
      std::scoped_lock<std::mutex> guard(mutex);
 
      if (this->types.Empty()) {
        this->types=types;
      }
      else {
        this->types.Add(types);
      }
 
      if (this->prefillData.empty()) {
        this->prefillData=data;
      }
      else {
        this->prefillData.reserve(this->prefillData.size()+data.size());
        this->prefillData.insert(this->prefillData.end(),data.begin(),data.end());
      }
 
      complete=false;
    }

    void AddPrefillData(const TypeInfoSet& types,
                        std::vector<O>&& data)
    {
      std::scoped_lock<std::mutex> guard(mutex);
 
      if (this->types.Empty()) {
        this->types=types;
      }
      else {
        this->types.Add(types);
      }
 
      if (this->prefillData.empty()) {
        this->prefillData=std::move(data);
      }
      else {
        this->prefillData.reserve(this->prefillData.size()+data.size());
        this->prefillData.insert(this->prefillData.end(),data.begin(),data.end());
      }
 
      complete=false;
    }

    void AddData(const TypeInfoSet& types,
                 const std::vector<O>& data)
    {
      std::scoped_lock<std::mutex> guard(mutex);
 
      this->data.insert(this->data.end(), data.begin(), data.end());
      this->types.Add(types);
 
      complete=true;
    }

    void SetData(const TypeInfoSet& types,
                 const std::vector<O>& data)
    {
      std::scoped_lock<std::mutex> guard(mutex);
 
      this->data=data;
      this->types=types;
 
      complete=true;
    }

    void SetData(const TypeInfoSet& types,
                 std::vector<O>&& data)
    {
      std::scoped_lock<std::mutex> guard(mutex);
 
      this->data=std::move(data);
      this->types=types;
 
      complete=true;
    }

    void SetComplete()
    {
      std::scoped_lock<std::mutex> guard(mutex);
 
      complete=true;
    }

    bool IsComplete() const
    {
      std::scoped_lock<std::mutex> guard(mutex);
 
      return complete;
    }

    TypeInfoSet GetTypes() const
    {
      std::scoped_lock<std::mutex> guard(mutex);
 
      return types;
    }
 
    size_t GetDataSize() const
    {
      std::scoped_lock<std::mutex> guard(mutex);
 
      return prefillData.size()+data.size();
    }
 
    void CopyData(std::function<void(const O&)> function) const
    {
      std::scoped_lock<std::mutex> guard(mutex);
 
      std::for_each(prefillData.begin(),prefillData.end(),function);
      std::for_each(data.begin(),data.end(),function);
    }
  };

  using TileNodeData = TileData<NodeRef>;

  using TileWayData = TileData<WayRef>;

  using TileAreaData = TileData<AreaRef>;

  using TileRouteData = TileData<RouteRef>;
 
  // Forward declaration of DataTileCache for friend declaration in Tile
  class DataTileCache;

  class OSMSCOUT_MAP_API Tile
  {
  private:
    TileKey       key;                
    GeoBox        boundingBox;       
    TileNodeData  nodeData;          
    TileWayData   wayData;           
    TileAreaData  areaData;          
    TileRouteData routeData;         
    TileWayData   optimizedWayData;  
    TileAreaData  optimizedAreaData; 
 
  private:
    explicit Tile(const TileKey& key);
 
  public:
    friend class DataTileCache;
 
    ~Tile() = default;

     TileKey GetKey() const
    {
      return key;
    }

     uint32_t GetLevel() const
    {
      return key.GetLevel();
    }

     GeoBox GetBoundingBox() const
    {
      return boundingBox;
    }

     const TileNodeData& GetNodeData() const
    {
      return nodeData;
    }

     const TileWayData& GetWayData() const
    {
      return wayData;
    }

     const TileAreaData& GetAreaData() const
    {
      return areaData;
    }

     const TileRouteData& GetRouteData() const
    {
      return routeData;
    }

     const TileWayData& GetOptimizedWayData() const
    {
      return optimizedWayData;
    }

     const TileAreaData& GetOptimizedAreaData() const
    {
      return optimizedAreaData;
    }

     TileNodeData& GetNodeData()
    {
      return nodeData;
    }

     TileWayData& GetWayData()
    {
      return wayData;
    }

     TileAreaData& GetAreaData()
    {
      return areaData;
    }

     TileRouteData& GetRouteData()
    {
      return routeData;
    }

     TileWayData& GetOptimizedWayData()
    {
      return optimizedWayData;
    }

     TileAreaData& GetOptimizedAreaData()
    {
      return optimizedAreaData;
    }

     bool IsComplete() const
    {
      return nodeData.IsComplete() &&
             wayData.IsComplete() &&
             areaData.IsComplete() &&
             routeData.IsComplete() &&
             optimizedWayData.IsComplete() &&
             optimizedAreaData.IsComplete();
    }

     bool IsEmpty() const
    {
      return nodeData.IsEmpty() &&
             wayData.IsEmpty() &&
             areaData.IsEmpty() &&
             routeData.IsEmpty() &&
             optimizedWayData.IsEmpty() &&
             optimizedAreaData.IsEmpty();
    }
  };

  using TileRef = std::shared_ptr<Tile>;

  class OSMSCOUT_MAP_API DataTileCache
  {
  private:
    struct OSMSCOUT_MAP_API CacheEntry
    {
      TileKey key;
      //TileWeakRef tile;
      TileRef tile;
 
      CacheEntry(const TileKey& key,
                 const TileRef /*TileWeakRef*/& tile)
              : key(key),
                tile(tile)
      {
        // no code
      }
    };

    using Cache = std::list<CacheEntry>;

    using CacheRef = Cache::iterator;

    using CacheIndex = std::map<TileKey, CacheRef>;
 
  private:
    size_t             cacheSize;
 
    mutable CacheIndex tileIndex;
    mutable Cache      tileCache;
 
    void ResolveNodesFromParent(Tile& tile,
                                const Tile& parentTile,
                                const GeoBox& boundingBox,
                                const TypeInfoSet& nodeTypes);
    void ResolveWaysFromParent(Tile& tile,
                               const Tile& parentTile,
                               const GeoBox& boundingBox,
                               const TypeInfoSet& wayTypes);
    void ResolveAreasFromParent(Tile& tile,
                                const Tile& parentTile,
                                const GeoBox& boundingBox,
                                const TypeInfoSet& areaTypes);
    void ResolveRoutesFromParent(Tile& route,
                                 const Tile& parentTile,
                                 const GeoBox& boundingBox,
                                 const TypeInfoSet& routeTypes);
 
  public:
    explicit DataTileCache(size_t cacheSize);
 
    void SetSize(size_t cacheSize);
 
     size_t GetSize() const
    {
      return cacheSize;
    }
 
     size_t GetCurrentSize() const
    {
      return tileCache.size();
    }
 
    void CleanupCache();
 
    void InvalidateCache();
 
    TileRef GetCachedTile(const TileKey& id) const;
    TileRef GetTile(const TileKey& id) const;
 
    void GetTilesForBoundingBox(const Magnification& magnification,
                                const GeoBox& boundingBox,
                                std::list<TileRef>& tiles) const;
 
    void PrefillDataFromCache(Tile& tile,
                              const TypeInfoSet& nodeTypes,
                              const TypeInfoSet& wayTypes,
                              const TypeInfoSet& areaTypes,
                              const TypeInfoSet& routeTypes,
                              const TypeInfoSet& optimizedWayTypes,
                              const TypeInfoSet& optimizedAreaTypes);
  };

  using TiledDataCacheRef = std::shared_ptr<DataTileCache>;

}
 
#endif