Database.h

Go to the documentation of this file.

#ifndef OSMSCOUT_DATABASE_H
#define OSMSCOUT_DATABASE_H
 
/*
  This source is part of the libosmscout library
  Copyright (C) 2009  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 <memory>
#include <mutex>
#include <set>
#include <unordered_map>
#include <vector>
#include <string_view>
 
// Type and style sheet configuration
#include <osmscout/OSMScoutTypes.h>
#include <osmscout/TypeConfig.h>
 
// Datafiles
#include <osmscout/db/AreaDataFile.h>
#include <osmscout/db/BoundingBoxDataFile.h>
#include <osmscout/db/NodeDataFile.h>
#include <osmscout/db/WayDataFile.h>
#include <osmscout/routing/RouteDataFile.h>
 
#include <osmscout/db/OptimizeAreasLowZoom.h>
#include <osmscout/db/OptimizeWaysLowZoom.h>
 
// In area index
#include <osmscout/db/AreaAreaIndex.h>
#include <osmscout/db/AreaNodeIndex.h>
#include <osmscout/db/AreaWayIndex.h>
#include <osmscout/db/AreaRouteIndex.h>
 
// Location index
#include <osmscout/db/LocationIndex.h>
 
// Water index
#include <osmscout/db/WaterIndex.h>
 
// SRTM index
#include <osmscout/elevation/SRTM.h>
 
#include <osmscout/routing/RouteDescription.h>
 
#include <osmscout/util/GeoBox.h>
 
#include <osmscout/system/Compiler.h>
 
namespace osmscout {


  class OSMSCOUT_API DatabaseParameter CLASS_FINAL
  {
  private:
    unsigned long areaAreaIndexCacheSize=5000;
 
    unsigned long nodeDataCacheSize=5'000;
    unsigned long wayDataCacheSize=40'000;
    unsigned long areaDataCacheSize=5'000;
    unsigned long routeDataCacheSize=1'500;
 
    bool routerDataMMap=true;
    bool nodesDataMMap=true;
    bool areasDataMMap=true;
    bool waysDataMMap=true;
    bool routesDataMMap=true;
    bool optimizeLowZoomMMap=true;
    bool indexMMap=true;
 
    // temporary, until we have our own db file
    std::string srtmDirectory;
 
  public:
    DatabaseParameter() = default;
 
    void SetAreaAreaIndexCacheSize(unsigned long areaAreaIndexCacheSize);
    void SetNodeDataCacheSize(unsigned long  size);
    void SetWayDataCacheSize(unsigned long  size);
    void SetAreaDataCacheSize(unsigned long  size);
    void SetRouteDataCacheSize(unsigned long  size);
 
    void SetRouterDataMMap(bool mmap);
    void SetNodesDataMMap(bool mmap);
    void SetAreasDataMMap(bool mmap);
    void SetWaysDataMMap(bool mmap);
    void SetRoutesDataMMap(bool mmap);
    void SetOptimizeLowZoomMMap(bool mmap);
    void SetIndexMMap(bool mmap);
 
    // Temporary
    void SetSRTMDirectory(const std::string& directory)
    {
      this->srtmDirectory=directory;
    }
 
    unsigned long GetAreaAreaIndexCacheSize() const;
    unsigned long GetNodeDataCacheSize() const;
    unsigned long GetWayDataCacheSize() const;
    unsigned long GetRouteDataCacheSize() const;
    unsigned long GetAreaDataCacheSize() const;
 
    bool GetRouterDataMMap() const;
    bool GetNodesDataMMap() const;
    bool GetAreasDataMMap() const;
    bool GetWaysDataMMap() const;
    bool GetRoutesDataMMap() const;
    bool GetOptimizeLowZoomMMap() const;
    bool GetIndexMMap() const;
 
    // Temporary
    std::string GetSRTMDirectory() const
    {
      return srtmDirectory;
    }
  };
 
  class Database;
 
  class OSMSCOUT_API NodeRegionSearchResultEntry
  {
  private:
    NodeRef  node;
    Distance distance;
 
  private:
    explicit NodeRegionSearchResultEntry(const NodeRef& node,
                                         const Distance &distance);
 
  public:
    friend Database;
 
    NodeRef GetNode() const
    {
      return node;
    }
 
    Distance GetDistance() const
    {
      return distance;
    }
  };
 
  class OSMSCOUT_API NodeRegionSearchResult
  {
  private:
    std::list<NodeRegionSearchResultEntry> nodeResults;
 
  public:
    friend Database;
 
    std::list<NodeRegionSearchResultEntry> GetNodeResults() const
    {
      return nodeResults;
    }
  };
 
 
  class OSMSCOUT_API WayRegionSearchResultEntry
  {
  private:
    WayRef   way;
    Distance distance;
    GeoCoord closestPoint;
 
  private:
    explicit WayRegionSearchResultEntry(const WayRef &way,
                                        const Distance &distance,
                                        const GeoCoord &closestPoint);
 
  public:
    friend Database;
 
    WayRef GetWay() const
    {
      return way;
    }
 
    Distance GetDistance() const
    {
      return distance;
    }
 
    GeoCoord GetClosestPoint() const
    {
      return closestPoint;
    }
  };
 
  class OSMSCOUT_API WayRegionSearchResult
  {
  private:
    std::list<WayRegionSearchResultEntry> wayResults;
 
  public:
    friend Database;
 
    std::list<WayRegionSearchResultEntry> GetWayResults() const
    {
      return wayResults;
    }
  };
 
  class OSMSCOUT_API AreaRegionSearchResultEntry
  {
  private:
    AreaRef  area;
    Distance distance;
    GeoCoord closestPoint;
    bool     inArea;
 
  private:
    explicit AreaRegionSearchResultEntry(const AreaRef &area,
                                         const Distance &distance,
                                         const GeoCoord &closestPoint,
                                         bool inArea);
 
  public:
    friend Database;
 
    AreaRef GetArea() const
    {
      return area;
    }
 
    Distance GetDistance() const
    {
      return distance;
    }
 
    GeoCoord GetClosestPoint() const
    {
      return closestPoint;
    }
 
    bool IsInArea() const
    {
      return inArea;
    }
  };
 
  class OSMSCOUT_API AreaRegionSearchResult
  {
  private:
    std::list<AreaRegionSearchResultEntry> areaResults;
 
  public:
    friend Database;
 
    std::list<AreaRegionSearchResultEntry> GetAreaResults() const
    {
      return areaResults;
    }
  };

  class OSMSCOUT_API Database CLASS_FINAL
  {
  private:
    DatabaseParameter               parameter;                
 
    std::string                     path;                     
    bool                            isOpen=false;             
 
    TypeConfigRef                   typeConfig;               
 
    mutable BoundingBoxDataFileRef  boundingBoxDataFile;      
    mutable std::mutex              boundingBoxDataFileMutex; 
 
    mutable NodeDataFileRef         nodeDataFile;             
    mutable std::mutex              nodeDataFileMutex;        
 
    mutable AreaDataFileRef         areaDataFile;             
    mutable std::mutex              areaDataFileMutex;        
 
    mutable WayDataFileRef          wayDataFile;              
    mutable std::mutex              wayDataFileMutex;         
 
    mutable RouteDataFileRef        routeDataFile;            
    mutable std::mutex              routeDataFileMutex;       
 
    mutable AreaNodeIndexRef        areaNodeIndex;            
    mutable std::mutex              areaNodeIndexMutex;       
 
    mutable AreaWayIndexRef         areaWayIndex;             
    mutable std::mutex              areaWayIndexMutex;        
 
    mutable AreaRouteIndexRef       areaRouteIndex;           
    mutable std::mutex              areaRouteIndexMutex;      
 
    mutable AreaAreaIndexRef        areaAreaIndex;            
    mutable std::mutex              areaAreaIndexMutex;       
 
    mutable LocationIndexRef        locationIndex;            
    mutable std::mutex              locationIndexMutex;       
 
    mutable WaterIndexRef           waterIndex;               
    mutable std::mutex              waterIndexMutex;          
 
    mutable OptimizeAreasLowZoomRef optimizeAreasLowZoom;     
    mutable std::mutex              optimizeAreasMutex;       
 
    mutable OptimizeWaysLowZoomRef  optimizeWaysLowZoom;      
    mutable std::mutex              optimizeWaysMutex;        
 
    mutable SRTMRef                 srtmIndex;
    mutable std::mutex              srtmIndexMutex;           
 
  private:
    template<typename DataFile, typename OffsetsCol, typename DataCol>
    bool GetObjectsByOffset(DataFile dataFile,
                            const OffsetsCol& offsets,
                            DataCol& objects,
                            const std::string_view &typeName) const
    {
      if (!dataFile) {
        return false;
      }
 
      StopClock runningTime;
 
      bool result=dataFile->GetByOffset(offsets.begin(), offsets.end(), offsets.size(), objects);
 
      if (runningTime.GetMilliseconds()>100) {
        log.Warn() << "Retrieving " << objects.size() << " " << typeName << " by offset took " << runningTime.ResultString();
      }
 
      return result;
    }
 
  public:
    explicit Database(const DatabaseParameter& parameter);
    ~Database();
 
    bool Open(const std::string& path);
    bool IsOpen() const;
    void Close();
 
    std::string GetPath() const;
    TypeConfigRef GetTypeConfig() const;
 
    const DatabaseParameter& GetParameter() const
    {
      return parameter;
    }
 
    BoundingBoxDataFileRef GetBoundingBoxDataFile() const;
 
    NodeDataFileRef GetNodeDataFile() const;
    AreaDataFileRef GetAreaDataFile() const;
    WayDataFileRef GetWayDataFile() const;
    RouteDataFileRef GetRouteDataFile() const;
 
    AreaNodeIndexRef GetAreaNodeIndex() const;
    AreaAreaIndexRef GetAreaAreaIndex() const;
    AreaWayIndexRef GetAreaWayIndex() const;
    AreaRouteIndexRef GetAreaRouteIndex() const;
 
    LocationIndexRef GetLocationIndex() const;
 
    WaterIndexRef GetWaterIndex() const;
 
    OptimizeAreasLowZoomRef GetOptimizeAreasLowZoom() const;
    OptimizeWaysLowZoomRef GetOptimizeWaysLowZoom() const;
 
    SRTMRef GetSRTMIndex() const;
 
    bool GetBoundingBox(GeoBox& boundingBox) const;
 
    bool GetNodeByOffset(const FileOffset& offset,
                         NodeRef& node) const;
    bool GetNodesByOffset(const std::vector<FileOffset>& offsets,
                          std::vector<NodeRef>& nodes) const;
    bool GetNodesByOffset(const std::vector<FileOffset>& offsets,
                          const GeoBox& boundingBox,
                          std::vector<NodeRef>& nodes) const;
    bool GetNodesByOffset(const std::set<FileOffset>& offsets,
                          std::vector<NodeRef>& nodes) const;
    bool GetNodesByOffset(const std::list<FileOffset>& offsets,
                          std::vector<NodeRef>& nodes) const;
    bool GetNodesByOffset(const std::set<FileOffset>& offsets,
                          std::unordered_map<FileOffset,NodeRef>& dataMap) const;
 
    bool GetAreaByOffset(const FileOffset& offset,
                         AreaRef& area) const;
 
    template<typename OffsetsCol, typename DataCol>
    bool GetAreasByOffset(const OffsetsCol& offsets,
                          DataCol& areas) const
    {
      using namespace std::string_view_literals;
      return GetObjectsByOffset(GetAreaDataFile(), offsets, areas, "areas"sv);
    }
 
    bool GetAreasByBlockSpan(const DataBlockSpan& span,
                             std::vector<AreaRef>& area) const;
    bool GetAreasByBlockSpans(const std::vector<DataBlockSpan>& spans,
                              std::vector<AreaRef>& areas) const;
 
 
    bool GetWayByOffset(const FileOffset& offset,
                        WayRef& way) const;
 
    template<typename OffsetsCol, typename DataCol>
    bool GetWaysByOffset(const OffsetsCol& offsets,
                         DataCol& ways) const
    {
      using namespace std::string_view_literals;
      return GetObjectsByOffset(GetWayDataFile(), offsets, ways, "ways"sv);
    }
 
    template<typename OffsetsCol, typename DataCol>
    bool GetRoutesByOffset(const OffsetsCol& offsets,
                           DataCol& routes) const
    {
      using namespace std::string_view_literals;
      return GetObjectsByOffset(GetRouteDataFile(), offsets, routes, "routes"sv);
    }

    NodeRegionSearchResult LoadNodesInRadius(const GeoCoord& location,
                                             const TypeInfoSet& types,
                                             Distance maxDistance=Distance::Of<Meter>(100)) const;

    WayRegionSearchResult LoadWaysInRadius(const GeoCoord& location,
                                           const TypeInfoSet& types,
                                           Distance maxDistance=Distance::Of<Meter>(100)) const;

    AreaRegionSearchResult LoadAreasInRadius(const GeoCoord& location,
                                             const TypeInfoSet& types,
                                             Distance maxDistance=Distance::Of<Meter>(100)) const;

    NodeRegionSearchResult LoadNodesInArea(const TypeInfoSet& types,
                                           const GeoBox& boundingBox) const;

    WayRegionSearchResult LoadWaysInArea(const TypeInfoSet& types,
                                         const GeoBox& boundingBox) const;

    AreaRegionSearchResult LoadAreasInArea(const TypeInfoSet& types,
                                           const GeoBox& boundingBox) const;
 
    void DumpStatistics() const;
 
    void FlushCache();
  };

  using DatabaseRef = std::shared_ptr<Database>;

}
 
#endif