TypeConfig.h

Go to the documentation of this file.

#ifndef OSMSCOUT_TYPECONFIG_H
#define OSMSCOUT_TYPECONFIG_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 <string>
#include <unordered_map>
#include <unordered_set>
#include <vector>

#include <osmscout/CoreImportExport.h>

#include <osmscout/ObjectRef.h>
#include <osmscout/OSMScoutTypes.h>
#include <osmscout/Tag.h>
#include <osmscout/TypeFeature.h>

#include <osmscout/util/FileScanner.h>
#include <osmscout/util/FileWriter.h>
#include <osmscout/util/TagErrorReporter.h>

#include <osmscout/system/Assert.h>

#include <osmscout/system/Compiler.h>

namespace osmscout {

  static const TypeId typeIgnore      = 0;

  class TypeInfo;

  using TypeInfoRef = std::shared_ptr<TypeInfo>;


  class OSMSCOUT_API TypeInfo CLASS_FINAL
  {
  public:
    static const uint8_t typeNode     = 1u << 0u; 
    static const uint8_t typeWay      = 1u << 1u; 
    static const uint8_t typeArea     = 1u << 2u; 
    static const uint8_t typeRelation = 1u << 3u; 

    enum class SpecialType : uint8_t {
      none         = 0,
      multipolygon = 1,
      routeMaster  = 2,
      route        = 3
    };

  public:
    struct TypeCondition
    {
      unsigned char    types;     
      TagConditionRef  condition; 
    };

  private:
    TypeId                                      nodeId=0;                      
    TypeId                                      wayId=0;                       
    TypeId                                      areaId=0;                      
    TypeId                                      routeId=0;                     
    std::string                                 name;                          
    size_t                                      index=0;                       

    bool                                        internal=false;                

    std::list<TypeCondition>                    conditions;                    
    std::unordered_map<std::string,size_t>      nameToFeatureMap;
    std::vector<FeatureInstance>                features;                      
    size_t                                      featureMaskBytes=0;            
    size_t                                      specialFeatureMaskBytes=0;     
    size_t                                      valueBufferSize=0;             

    bool                                        canBeNode=false;               
    bool                                        canBeWay=false;                
    bool                                        canBeArea=false;               
    bool                                        canBeRelation=false;           
    bool                                        isPath=false;                  
    bool                                        canRouteFoot=false;            
    bool                                        canRouteBicycle=false;         
    bool                                        canRouteCar=false;             
    bool                                        indexAsAddress=false;          
    bool                                        indexAsLocation=false;         
    bool                                        indexAsRegion=false;           
    bool                                        indexAsPOI=false;              
    bool                                        optimizeLowZoom=false;         
    SpecialType                                 specialType=SpecialType::none; 
    bool                                        pinWay=false;                  
    bool                                        mergeAreas=false;              
    bool                                        ignoreSeaLand=false;           
    bool                                        ignore=false;                  
    uint8_t                                     lanes=1;                       
    uint8_t                                     onewayLanes=1;                 

    std::unordered_set<std::string>             groups;                        
    std::unordered_map<std::string,std::string> descriptions;                  

  private:
    TypeInfo(const TypeInfo& other) = delete;

    TypeInfo& operator=(const TypeInfo& other) = delete;

  public:
    explicit TypeInfo(const std::string& name);

    TypeInfo& SetNodeId(TypeId id);

    TypeInfo& SetWayId(TypeId id);

    TypeInfo& SetAreaId(TypeId id);

    TypeInfo& SetRouteId(TypeId id);

    TypeInfo& SetIndex(size_t index);

    TypeInfo& SetInternal();

    TypeInfo& SetType(const std::string& name);

    TypeInfo& AddCondition(unsigned char types,
                           const TagConditionRef& condition);

    TypeInfo& AddFeature(const FeatureRef& feature);

    TypeInfo& AddGroup(const std::string& groupName);

    TypeInfo& AddDescription(const std::string& languageCode,
                             const std::string& description);

    bool HasFeatures() const
    {
      return !features.empty();
    }

    bool HasFeature(const std::string& featureName) const;

    bool GetFeature(const std::string& name,
                    size_t& index) const;

    const FeatureInstance& GetFeature(size_t idx) const
    {
      return features[idx];
    }

    const std::vector<FeatureInstance>& GetFeatures() const
    {
      return features;
    }

    size_t GetFeatureCount() const
    {
      return features.size();
    }

    size_t GetFeatureMaskBytes() const
    {
      return featureMaskBytes;
    }

    size_t GetSpecialFeatureMaskBytes() const
    {
      return specialFeatureMaskBytes;
    }

    size_t GetFeatureValueBufferSize() const
    {
      return valueBufferSize;
    }

    TypeId GetNodeId() const
    {
      return nodeId;
    }

    TypeId GetWayId() const
    {
      return wayId;
    }

    TypeId GetAreaId() const
    {
      return areaId;
    }

    TypeId GetRouteId() const
    {
      return routeId;
    }

    size_t GetIndex() const
    {
      return index;
    }

    bool IsInternal() const
    {
      return internal;
    }

    std::string GetName() const
    {
      return name;
    }

    bool HasConditions() const
    {
      return !conditions.empty();
    }

    const std::list<TypeCondition>& GetConditions() const
    {
      return conditions;
    }

    TypeInfo& CanBeNode(bool canBeNode)
    {
      this->canBeNode=canBeNode;

      return *this;
    }

    bool CanBeNode() const
    {
      return canBeNode;
    }

    TypeInfo& CanBeWay(bool canBeWay)
    {
      this->canBeWay=canBeWay;

      return *this;
    }

    bool CanBeWay() const
    {
      return canBeWay;
    }

    TypeInfo& CanBeArea(bool canBeArea)
    {
      this->canBeArea=canBeArea;

      return *this;
    }

    bool CanBeArea() const
    {
      return canBeArea;
    }

    TypeInfo& CanBeRelation(bool canBeRelation)
    {
      this->canBeRelation=canBeRelation;

      return *this;
    }

    bool CanBeRelation() const
    {
      return canBeRelation;
    }

    TypeInfo& SetIsPath(bool isPath)
    {
      this->isPath=isPath;

      return *this;
    }

    bool IsPath() const
    {
      return isPath;
    }

    TypeInfo& CanRouteFoot(bool canBeRoute)
    {
      this->canRouteFoot=canBeRoute;

      return *this;
    }

    TypeInfo& CanRouteBicycle(bool canBeRoute)
    {
      this->canRouteBicycle=canBeRoute;

      return *this;
    }

    TypeInfo& CanRouteCar(bool canBeRoute)
    {
      this->canRouteCar=canBeRoute;

      return *this;
    }

    bool CanRoute() const
    {
      return canRouteFoot || canRouteBicycle || canRouteCar;
    }

    bool CanRoute(Vehicle vehicle) const
    {
      switch (vehicle)
      {
      case vehicleFoot:
        return canRouteFoot;
      case vehicleBicycle:
        return canRouteBicycle;
      case vehicleCar:
        return canRouteCar;
      }

      return false;
    }

    bool CanRouteFoot() const
    {
      return canRouteFoot;
    }

    bool CanRouteBicycle() const
    {
      return canRouteBicycle;
    }

    bool CanRouteCar() const
    {
      return canRouteCar;
    }

    uint8_t GetDefaultAccess() const;

    TypeInfo& SetIndexAsAddress(bool indexAsAddress)
    {
      this->indexAsAddress=indexAsAddress;

      return *this;
    }

    bool GetIndexAsAddress() const
    {
      return indexAsAddress;
    }

    TypeInfo& SetIndexAsLocation(bool indexAsLocation)
    {
      this->indexAsLocation=indexAsLocation;

      return *this;
    }

    bool GetIndexAsLocation() const
    {
      return indexAsLocation;
    }

    TypeInfo& SetIndexAsRegion(bool indexAsRegion)
    {
      this->indexAsRegion=indexAsRegion;

      return *this;
    }

    bool GetIndexAsRegion() const
    {
      return indexAsRegion;
    }

    TypeInfo& SetIndexAsPOI(bool indexAsPOI)
    {
      this->indexAsPOI=indexAsPOI;

      return *this;
    }

    bool GetIndexAsPOI() const
    {
      return indexAsPOI;
    }

    TypeInfo& SetOptimizeLowZoom(bool optimize)
    {
      this->optimizeLowZoom=optimize;

      return *this;
    }

    bool GetOptimizeLowZoom() const
    {
      return optimizeLowZoom;
    }

    TypeInfo& SetSpecialType(SpecialType specialType) {
      this->specialType=specialType;

      return *this;
    }

    SpecialType GetSpecialType() const
    {
      return specialType;
    }
    TypeInfo& SetMultipolygon()
    {
      this->specialType=SpecialType::multipolygon;

      return *this;
    }

    TypeInfo& SetRouteMaster()
    {
      this->specialType=SpecialType::routeMaster;

      return *this;
    }

    TypeInfo& SetRoute()
    {
      this->specialType=SpecialType::route;

      return *this;
    }

    bool IsMultipolygon() const
    {
      return specialType==SpecialType::multipolygon;
    }

    bool IsRouteMaster() const
    {
      return specialType==SpecialType::routeMaster;
    }

    bool IsRoute() const
    {
      return specialType==SpecialType::route;
    }

    TypeInfo& SetPinWay(bool pinWay)
    {
      this->pinWay=pinWay;

      return *this;
    }

    bool GetPinWay() const
    {
      return pinWay;
    }

    TypeInfo& SetMergeAreas(bool mergeAreas)
    {
      this->mergeAreas=mergeAreas;

      return *this;
    }

    bool GetMergeAreas() const
    {
      return mergeAreas;
    }

    TypeInfo& SetIgnoreSeaLand(bool ignoreSeaLand)
    {
      this->ignoreSeaLand=ignoreSeaLand;

      return *this;
    }

    bool GetIgnoreSeaLand() const
    {
      return ignoreSeaLand;
    }

    TypeInfo& SetIgnore(bool ignore)
    {
      this->ignore=ignore;

      return *this;
    }

    bool GetIgnore() const
    {
      return ignore;
    }

    TypeInfo& SetLanes(uint8_t lanes)
    {
      this->lanes=lanes;

      return *this;
    }

    uint8_t GetLanes() const
    {
      return lanes;
    }

    TypeInfo& SetOnewayLanes(uint8_t lanes)
    {
      this->onewayLanes=lanes;

      return *this;
    }

    uint8_t GetOnewayLanes() const
    {
      return onewayLanes;
    }

    const std::unordered_set<std::string>& GetGroups() const
    {
      return groups;
    }

    bool IsInGroup(const std::string& groupName) const
    {
      return groups.find(groupName)!=groups.end();
    }

    const std::unordered_map<std::string,std::string>& GetDescriptions() const
    {
      return descriptions;
    };

    std::string GetDescription(const std::string& languageCode) const;

    static TypeInfoRef Read(FileScanner& scanner);
  };

  class OSMSCOUT_API FeatureValueBuffer CLASS_FINAL
  {
  private:
    TypeInfoRef type;
    uint8_t     *featureBits;
    char        *featureValueBuffer;

  private:
    void DeleteData();
    void AllocateBits();
    void AllocateValueBufferLazy();

    FeatureValue* GetValueAndAllocateBuffer(size_t idx)
    {
      AllocateValueBufferLazy();
      return static_cast<FeatureValue*>(static_cast<void*>(&featureValueBuffer[type->GetFeature(idx).GetOffset()]));
    }

  public:
    FeatureValueBuffer();
    FeatureValueBuffer(const FeatureValueBuffer& other);
    ~FeatureValueBuffer();

    void Set(const FeatureValueBuffer& other);

    void CopyMissingValues(const FeatureValueBuffer& other);

    void ClearFeatureValues();

    void SetType(const TypeInfoRef& type);

    TypeInfoRef GetType() const
    {
      return type;
    }

    size_t GetFeatureCount() const
    {
      return type->GetFeatureCount();
    }

    FeatureInstance GetFeature(size_t idx) const
    {
      return type->GetFeature(idx);
    }

    bool HasFeature(size_t idx) const
    {
      size_t featureBit=type->GetFeature(idx).GetFeatureBit();

      return (featureBits[featureBit/8] & (1u << featureBit%8))!=0;
    }

    FeatureValue* GetValue(size_t idx) const
    {
      return featureValueBuffer==nullptr ? nullptr
                                         : static_cast<FeatureValue*>(static_cast<void*>(&featureValueBuffer[type->GetFeature(idx).GetOffset()]));
    }

    FeatureValue* AllocateValue(size_t idx);
    void FreeValue(size_t idx);

    void Parse(TagErrorReporter& errorReporter,
               const TagRegistry& tagRegistry,
               const ObjectOSMRef& object,
               const TagMap& tags);

    void Read(FileScanner& scanner);
    void Read(FileScanner& scanner,
              bool& specialFlag);
    void Read(FileScanner& scanner,
              bool& specialFlag1,
              bool& specialFlag2);
    void Write(FileWriter& writer) const;
    void Write(FileWriter& writer,
               bool specialFlag) const;
    void Write(FileWriter& writer,
               bool specialFlag1,
               bool specialFlag2) const;

    FeatureValueBuffer& operator=(const FeatureValueBuffer& other);
    bool operator==(const FeatureValueBuffer& other) const;
    bool operator!=(const FeatureValueBuffer& other) const;

    template<class T> const T* findValue() const
    {
      for (const auto& featureInstance :GetType()->GetFeatures()) {
        if (HasFeature(featureInstance.GetIndex())) {
          osmscout::FeatureRef feature=featureInstance.GetFeature();
          if (feature->HasValue()) {
            const osmscout::FeatureValue* value=GetValue(featureInstance.GetIndex());
            const auto *v=dynamic_cast<const T*>(value);
            if (v!=nullptr) {
              return v;
            }
          }
        }
      }

      return nullptr;
    }
  };

  using FeatureValueBufferRef = std::shared_ptr<FeatureValueBuffer>;

  // Forward declaration
  class TypeConfig;

  static const uint32_t FILE_FORMAT_VERSION=22;

  class OSMSCOUT_API TypeConfig CLASS_FINAL
  {
  public:
    static const char* FILE_TYPES_DAT;
    static const uint32_t MIN_FORMAT_VERSION = FILE_FORMAT_VERSION;
    static const uint32_t MAX_FORMAT_VERSION = FILE_FORMAT_VERSION;

  private:
    // Tags
    TagRegistry                                 tagRegistry;

    // Types

    std::vector<TypeInfoRef>                    types;
    std::vector<TypeInfoRef>                    nodeTypes;
    std::vector<TypeInfoRef>                    wayTypes;
    std::vector<TypeInfoRef>                    areaTypes;
    std::vector<TypeInfoRef>                    routeTypes;

    uint8_t                                     nodeTypeIdBytes=1;
    uint8_t                                     wayTypeIdBytes=1;
    uint8_t                                     areaTypeIdBits=1;
    uint8_t                                     areaTypeIdBytes=1;
    uint8_t                                     routeTypeIdBytes=1;

    std::unordered_map<std::string,TypeInfoRef> nameToTypeMap;

    // Features

    std::vector<FeatureRef>                     features;

    std::unordered_map<std::string,FeatureRef>  nameToFeatureMap;

    FeatureRef                                  featureName;
    FeatureRef                                  featureNameShort;
    FeatureRef                                  featureRef;
    FeatureRef                                  featureLocation;
    FeatureRef                                  featureAddress;
    FeatureRef                                  featurePostalCode;
    FeatureRef                                  featureWebsite;
    FeatureRef                                  featurePhone;
    FeatureRef                                  featureAccess;
    FeatureRef                                  featureAccessRestricted;
    FeatureRef                                  featureLayer;
    FeatureRef                                  featureWidth;
    FeatureRef                                  featureMaxSpeed;
    FeatureRef                                  featureGrade;
    FeatureRef                                  featureBridge;
    FeatureRef                                  featureTunnel;
    FeatureRef                                  featureEmbankment;
    FeatureRef                                  featureRoundabout;
    FeatureRef                                  featureLanes;

  public:
    // Internal use (only available during preprocessing)
    TagId                                       tagArea;
    TagId                                       tagNatural;
    TagId                                       tagDataPolygon;
    TagId                                       tagType;
    TagId                                       tagRestriction;
    TagId                                       tagJunction;

    TypeInfoRef                                 typeInfoIgnore;
    TypeInfoRef                                 typeInfoTileLand;         
    TypeInfoRef                                 typeInfoTileSea;          
    TypeInfoRef                                 typeInfoTileCoast;        
    TypeInfoRef                                 typeInfoTileUnknown;      
    TypeInfoRef                                 typeInfoCoastline;        
    TypeInfoRef                                 typeInfoOSMTileBorder;    
    TypeInfoRef                                 typeInfoOSMSubTileBorder; 

  public:
    TypeConfig();
    ~TypeConfig();

    TagId GetTagId(const char* name) const
    {
      return tagRegistry.GetTagId(name);
    }

    TagId GetTagId(const std::string& name) const
    {
      return tagRegistry.GetTagId(name);
    }

    const TagRegistry& GetTagRegistry() const
    {
      return tagRegistry;
    }

    TagRegistry& GetTagRegistry()
    {
      return tagRegistry;
    }

    void RegisterSurfaceToGradeMapping(const std::string& surface,
                                              size_t grade)
    {
      tagRegistry.RegisterSurfaceToGradeMapping(surface,
                                                grade);
    }

    void RegisterMaxSpeedAlias(const std::string& alias,
                                      uint8_t maxSpeed)
    {
      tagRegistry.RegisterMaxSpeedAlias(alias,
                                        maxSpeed);
    }

    TypeInfoRef RegisterType(const TypeInfoRef& typeInfo);

    const std::vector<TypeInfoRef>& GetTypes() const
    {
      return types;
    }

    const std::vector<TypeInfoRef>& GetNodeTypes() const
    {
      return nodeTypes;
    }

    uint8_t GetNodeTypeIdBytes() const
    {
      return nodeTypeIdBytes;
    }

    const std::vector<TypeInfoRef>& GetWayTypes() const
    {
      return wayTypes;
    }

    uint8_t GetWayTypeIdBytes() const
    {
      return wayTypeIdBytes;
    }

    const std::vector<TypeInfoRef>& GetAreaTypes() const
    {
      return areaTypes;
    }

    uint8_t GetAreaTypeIdBits() const
    {
      return areaTypeIdBits;
    }

    uint8_t GetAreaTypeIdBytes() const
    {
      return areaTypeIdBytes;
    }

    const std::vector<TypeInfoRef>& GetRouteTypes() const
    {
      return routeTypes;
    }

    uint8_t GetRouteTypeIdBytes() const
    {
      return routeTypeIdBytes;
    }

    size_t GetTypeCount() const
    {
      return types.size();
    }

    TypeId GetMaxTypeId() const;

    TypeInfoRef GetTypeInfo(size_t index) const
    {
      assert(index<types.size());

      return types[index];
    }

    TypeInfoRef GetNodeTypeInfo(TypeId id) const
    {
      assert(id<=nodeTypes.size());

      if (id==typeIgnore) {
        return typeInfoIgnore;
      }

      return nodeTypes[id-1];
    }

    TypeInfoRef GetWayTypeInfo(TypeId id) const
    {
      assert(id<=wayTypes.size());

      if (id==typeIgnore) {
        return typeInfoIgnore;
      }

      return wayTypes[id-1];
    }

    TypeInfoRef GetAreaTypeInfo(TypeId id) const
    {
      assert(id<=areaTypes.size());

      if (id==typeIgnore) {
        return typeInfoIgnore;
      }

      return areaTypes[id-1];
    }

    TypeInfoRef GetRouteTypeInfo(TypeId id) const
    {
      assert(id<=routeTypes.size());

      if (id==typeIgnore) {
        return typeInfoIgnore;
      }

      return routeTypes[id-1];
    }

    const TypeInfoRef GetTypeInfo(const std::string& name) const;

    TypeInfoRef GetNodeType(const TagMap& tagMap) const;

    bool GetWayAreaType(const TagMap& tagMap,
                        TypeInfoRef& wayType,
                        TypeInfoRef& areaType) const;

    TypeInfoRef GetRelationType(const TagMap& tagMap) const;

    void RegisterFeature(const FeatureRef& feature);

    FeatureRef GetFeature(const std::string& name) const;

    const std::vector<FeatureRef>& GetFeatures() const
    {
      return features;
    }

    bool LoadFromOSTFile(const std::string& filename);
    bool LoadFromDataFile(const std::string& directory);
    bool StoreToDataFile(const std::string& directory) const;
  };


  using TypeConfigRef = std::shared_ptr<TypeConfig>;

}

#endif