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/CoreFeatures.h>

#include <osmscout/Point.h>

#include <osmscout/TypeConfig.h>

#include <osmscout/routing/RouteNode.h>

// Datafiles
#include <osmscout/DataFile.h>
#include <osmscout/Database.h>
#include <osmscout/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/util/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;
    DatabaseId    database;

  public:
    RoutePosition();
    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;            
      ObjectFileRef object;          

      double        currentCost=0;   
      double        estimateCost=0;  
      double        overallCost=0;   

      bool          access=true;     

      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)
      : id(id),
        node(node),
        prev(prev),
        object(object),
        currentCost(0),
        estimateCost(0),
        overallCost(0),
        access(true)
      {
        // 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;   
      DBId          previousNode;  
      ObjectFileRef object;        

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

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

      VNode(const DBId& currentNode,
            const ObjectFileRef& object,
            const DBId& previousNode)
      : currentNode(currentNode),
        previousNode(previousNode),
        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);
      }
    };

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