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 <osmscout/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