RouteNode.h

Go to the documentation of this file.

#ifndef OSMSCOUT_ROUTENODE_H
#define OSMSCOUT_ROUTENODE_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 <memory>
#include <vector>
 
#include <osmscout/ObjectRef.h>
#include <osmscout/Path.h>
#include <osmscout/OSMScoutTypes.h>
#include <osmscout/TypeConfig.h>
 
#include <osmscout/io/FileScanner.h>
#include <osmscout/io/FileWriter.h>
 
namespace osmscout {

  struct OSMSCOUT_API ObjectVariantData
  {
  public:
    TypeInfoRef type;     
    uint8_t     maxSpeed; 
    uint8_t     grade;    
 
    bool operator==(const ObjectVariantData& other) const;
    bool operator<(const ObjectVariantData& other) const;
 
    void Read(const TypeConfig& typeConfig,
              FileScanner& scanner);
    void Write(FileWriter& writer) const;
  };

  class OSMSCOUT_API RouteNode
  {
  public:
    static const uint8_t usableByFoot         = 1u << 0u; 
    static const uint8_t usableByBicycle      = 1u << 1u; 
    static const uint8_t usableByCar          = 1u << 2u; 
    static const uint8_t restrictedForFoot    = 1u << 3u; 
    static const uint8_t restrictedForBicycle = 1u << 4u; 
    static const uint8_t restrictedForCar     = 1u << 5u; 

    struct OSMSCOUT_API ObjectData
    {
      ObjectFileRef object;             
      uint16_t      objectVariantIndex; 
    };

    struct OSMSCOUT_API Exclude
    {
      ObjectFileRef source;      
      uint8_t       targetIndex; 
    };

    struct OSMSCOUT_API Path
    {
      Distance   distance;    
      Id         id;          
      uint8_t    objectIndex; 
      uint8_t    flags;       
 
      bool IsUsable(Vehicle vehicle) const
      {
        switch (vehicle) {
          case vehicleFoot:
            return (flags & usableByFoot) != 0;
          case vehicleBicycle:
            return (flags & usableByBicycle) != 0;
          case vehicleCar:
            return (flags & usableByCar) != 0;
        }
 
        return false;
      }
 
      bool IsRestricted(Vehicle vehicle) const
      {
        switch (vehicle) {
        case vehicleFoot:
          return (flags & restrictedForFoot) != 0;
        case vehicleBicycle:
          return (flags & restrictedForBicycle) != 0;
        case vehicleCar:
          return (flags & restrictedForCar) != 0;
        }
 
        return false;
      }
    };
 
  private:
    FileOffset              fileOffset; 
    Point                   point;      
 
  public:
    std::vector<ObjectData> objects;    
    std::vector<Path>       paths;      
    std::vector<Exclude>    excludes;   
 
    FileOffset GetFileOffset() const
    {
      return fileOffset;
    }
 
    Id GetId() const
    {
      return point.GetId();
    }
 
    GeoCoord GetCoord() const
    {
      return point.GetCoord();
    }
 
    Point GetPoint() const {
      return point;
    }
 
    void Initialize(FileOffset fileOffset,
                    const Point& point)
    {
      this->fileOffset=fileOffset;
      this->point=point;
    }
 
    uint8_t AddObject(const ObjectFileRef& object,
                      uint16_t objectVariantIndex);
 
    void Read(FileScanner& scanner);
    void Read(const TypeConfig& typeConfig,
              FileScanner& scanner);
    void Write(FileWriter& writer) const;
  };
 
  using RouteNodeRef = std::shared_ptr<RouteNode>;
}
 
#endif