RoutingService.h

Go to the documentation of this file.

#ifndef OSMSCOUT_ROUTINGSERVICE_H
#define OSMSCOUT_ROUTINGSERVICE_H
 
/*
  This source is part of the libosmscout library
  Copyright (C) 2012  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 <atomic>
#include <functional>
#include <list>
#include <memory>
#include <set>
#include <unordered_map>
#include <unordered_set>
 
#include <osmscout/lib/CoreFeatures.h>
 
#include <osmscout/Point.h>
 
#include <osmscout/TypeConfig.h>
 
#include <osmscout/routing/RouteNode.h>
 
// Datafiles
#include <osmscout/io/DataFile.h>
 
#include <osmscout/db/Database.h>
#include <osmscout/db/ObjectVariantDataFile.h>
 
// Routing
#include <osmscout/Intersection.h>
#include <osmscout/routing/RouteDescription.h>
#include <osmscout/routing/RouteData.h>
#include <osmscout/routing/RouteNodeDataFile.h>
#include <osmscout/routing/RoutingProfile.h>
#include <osmscout/routing/DBFileOffset.h>
 
#include <osmscout/async/Breaker.h>
#include <osmscout/util/Cache.h>
 
#include <osmscout/system/Compiler.h>
 
namespace osmscout {

  class OSMSCOUT_API RoutePosition CLASS_FINAL
  {
  private:
    ObjectFileRef object;
    size_t        nodeIndex=0;
    DatabaseId    database;
 
  public:
    RoutePosition() = default;
    RoutePosition(const ObjectFileRef& object,
                  size_t nodeIndex,
                  DatabaseId database);
 
    bool IsValid() const
    {
      return object.Valid();
    }
 
    ObjectFileRef GetObjectFileRef() const
    {
      return object;
    }
 
    size_t GetNodeIndex() const
    {
      return nodeIndex;
    }
 
    DatabaseId GetDatabaseId() const
    {
      return database;
    }
  };
 
  class OSMSCOUT_API RoutePositionResult CLASS_FINAL
  {
  private:
    RoutePosition routePosition;
    Distance distance;
 
  public:
    RoutePositionResult();
 
    RoutePositionResult(const RoutePosition &routePosition, const Distance &distance);
 
    RoutePosition GetRoutePosition() const
    {
      return routePosition;
    }
 
    Distance GetDistance() const
    {
      return distance;
    }
 
    bool IsValid() const
    {
      return routePosition.IsValid();
    }
  };
 

  class OSMSCOUT_API RouterParameter CLASS_FINAL
  {
  private:
    bool          debugPerformance;
 
  public:
    RouterParameter();
 
    void SetDebugPerformance(bool debug);
 
    bool IsDebugPerformance() const;
  };

  class OSMSCOUT_API RoutingProgress
  {
  public:
    virtual ~RoutingProgress() = default;

    virtual void Reset() = 0;

    virtual void Progress(const Distance &currentMaxDistance,
                          const Distance &overallDistance) = 0;
  };

  using RoutingProgressRef = std::shared_ptr<RoutingProgress>;

  class OSMSCOUT_API RoutingParameter CLASS_FINAL
  {
  private:
    BreakerRef         breaker;
    RoutingProgressRef progress;
 
  public:
    void SetBreaker(const BreakerRef& breaker);
    void SetProgress(const RoutingProgressRef& progress);
 
    BreakerRef GetBreaker() const
    {
      return breaker;
    }
 
    RoutingProgressRef GetProgress() const
    {
      return progress;
    }
  };

  class OSMSCOUT_API RoutingService
  {
  protected:
    struct RNode
    {
      DBId          id;                   
      RouteNodeRef  node;                 
      DBId          prev;                 
      Id            exclude;              
      bool          prevRestricted=false; 
      ObjectFileRef object;               
 
      double        currentCost=0;        
      double        estimateCost=0;       
      double        overallCost=0;        
 
      bool          restricted=true;      

      bool          leaveRestricted=false;
 
      RNode() = default;
 
      RNode(const DBId& id,
            const RouteNodeRef& node,
            const ObjectFileRef& object)
      : id(id),
        node(node),
        object(object)
      {
        // no code
      }
 
      RNode(const DBId& id,
            const RouteNodeRef& node,
            const ObjectFileRef& object,
            const DBId& prev,
            bool prevRestricted)
      : id(id),
        node(node),
        prev(prev),
        prevRestricted(prevRestricted),
        object(object)
      {
        // no code
      }
 
      bool operator==(const RNode& other) const
      {
        return id==other.id;
      }
 
      bool operator<(const RNode& other) const
      {
        return id<other.id;
      }
    };
 
    using RNodeRef = std::shared_ptr<RNode>;
 
    struct RNodeCostCompare
    {
      bool operator()(const RNodeRef& a,
                      const RNodeRef& b) const
      {
        if (a->overallCost==b->overallCost) {
         return a->id<b->id;
        }
 
        return a->overallCost<b->overallCost;
      }
    };

    struct VNode
    {
      DBId          currentNode;              
      bool          currentRestricted=false;  
      DBId          previousNode;             
      bool          previousRestricted=false; 
      ObjectFileRef object;                   

      bool operator==(const VNode& other) const
      {
        return currentNode==other.currentNode && currentRestricted==other.currentRestricted;
      }

      explicit VNode(const DBId& currentNode, bool currentRestricted)
        : currentNode(currentNode), currentRestricted(currentRestricted)
      {
        // no code
      }

      VNode(const DBId& currentNode,
            bool currentRestricted,
            const ObjectFileRef& object,
            const DBId& previousNode,
            bool previousRestricted)
      : currentNode(currentNode),
        currentRestricted(currentRestricted),
        previousNode(previousNode),
        previousRestricted(previousRestricted),
        object(object)
      {
        // no code
      }
    };

    struct ClosedNodeHasher
    {
      size_t operator()(const VNode& node) const
      {
        return std::hash<Id>()(node.currentNode.id) ^
               std::hash<DatabaseId>()(node.currentNode.database) ^
               std::hash<bool>()(node.currentRestricted);
      }
    };
 
    using OpenList    = std::set<RNodeRef, RNodeCostCompare>;
    using OpenListRef = std::set<RNodeRef, RNodeCostCompare>::iterator;
 
    using OpenMap     = std::unordered_map<DBId, OpenListRef>;
    using ClosedSet   = std::unordered_set<VNode, ClosedNodeHasher>;
 
  public:
    static const char* const FILENAME_INTERSECTIONS_DAT;
    static const char* const FILENAME_INTERSECTIONS_IDX;

    static const char* const DEFAULT_FILENAME_BASE;
 
    static std::string GetDataFilename(const std::string& filenamebase);
    static std::string GetData2Filename(const std::string& filenamebase);
    static std::string GetIndexFilename(const std::string& filenamebase);
 
  public:
    RoutingService();
    virtual ~RoutingService();
  };
 
}
 
#endif /* OSMSCOUT_ROUTINGSERVICE_H */