Tag.h

Go to the documentation of this file.

#ifndef OSMSCOUT_TAG_H
#define OSMSCOUT_TAG_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/util/Parsing.h>

#include <osmscout/system/Compiler.h>
#include <osmscout/system/SystemTypes.h>

namespace osmscout {

  using TagId = uint16_t;

  using TagMap = std::unordered_map<TagId, std::string>;

  static const TagId tagIgnore = 0;

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

    virtual bool Evaluate(const TagMap& tagMap) const = 0;
  };

  using TagConditionRef = std::shared_ptr<TagCondition>;

  class OSMSCOUT_API TagNotCondition : public TagCondition
  {
  private:
    TagConditionRef condition;

  public:
    explicit TagNotCondition(const TagConditionRef& condition);

    inline bool Evaluate(const TagMap& tagMap) const override
    {
      return !condition->Evaluate(tagMap);
    }
  };

  class OSMSCOUT_API TagBoolCondition : public TagCondition
  {
  public:
    enum Type {
      boolAnd,
      boolOr
    };

  private:
    std::list<TagConditionRef> conditions;
    Type                       type;

  public:
    explicit TagBoolCondition(Type type);

    void AddCondition(const TagConditionRef& condition);

    bool Evaluate(const TagMap& tagMap) const override;
  };

  using TagBoolConditionRef = std::shared_ptr<TagBoolCondition>;

  class OSMSCOUT_API TagExistsCondition : public TagCondition
  {
  private:
    TagId tag;

  public:
    explicit TagExistsCondition(TagId tag);

    inline bool Evaluate(const TagMap& tagMap) const override
    {
      return tagMap.find(tag)!=tagMap.end();
    }
  };

  class OSMSCOUT_API TagBinaryCondition : public TagCondition
  {
  private:
    enum ValueType {
      string,
      sizet
    };

  private:
    TagId          tag;
    BinaryOperator binaryOperator;
    ValueType      valueType;
    std::string    tagStringValue;
    size_t         tagSizeValue;

  public:
    TagBinaryCondition(TagId tag,
                       BinaryOperator binaryOperator,
                       const std::string& tagValue);
    TagBinaryCondition(TagId tag,
                       BinaryOperator binaryOperator,
                       const size_t& tagValue);

    bool Evaluate(const TagMap& tagMap) const override;
  };

  class OSMSCOUT_API TagIsInCondition : public TagCondition
  {
  private:
    TagId                           tag;
    std::unordered_set<std::string> tagValues;

  public:
    explicit TagIsInCondition(TagId tag);

    void AddTagValue(const std::string& tagValue);

    bool Evaluate(const TagMap& tagMap) const override;
  };

  using TagIsInConditionRef = std::shared_ptr<TagIsInCondition>;

  class OSMSCOUT_API TagInfo
  {
  private:
    TagId       id;
    std::string name;

  public:
    TagInfo(TagId id,
            const std::string& name);

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

    inline TagId GetId() const
    {
      return id;
    }
  };

  class OSMSCOUT_API TagRegistry CLASS_FINAL
  {
  private:
    // Tags

    std::vector<TagInfo>                        tags;

    TagId                                       nextTagId;

    std::unordered_map<std::string,TagId>       stringToTagMap;
    std::unordered_map<TagId,uint32_t>          nameTagIdToPrioMap;
    std::unordered_map<TagId,uint32_t>          nameAltTagIdToPrioMap;
    std::unordered_map<std::string,uint8_t>     nameToMaxSpeedMap;

    std::unordered_map<std::string,size_t>      surfaceToGradeMap;

  public:
    TagRegistry();
    ~TagRegistry();

    TagId RegisterTag(const std::string& tagName);

    TagId RegisterNameTag(const std::string& tagName,
                          uint32_t priority);
    TagId RegisterNameAltTag(const std::string& tagName,
                             uint32_t priority);

    TagId GetTagId(const char* name) const;
    TagId GetTagId(const std::string& name) const;

    bool IsNameTag(TagId tag,
                   uint32_t& priority) const;
    bool IsNameAltTag(TagId tag,
                      uint32_t& priority) const;

    void RegisterSurfaceToGradeMapping(const std::string& surface,
                                       size_t grade);
    bool GetGradeForSurface(const std::string& surfaceValue,
                            size_t& grade) const;

    void RegisterMaxSpeedAlias(const std::string& alias,
                               uint8_t maxSpeed);
    bool GetMaxSpeedFromAlias(const std::string& alias,
                              uint8_t& maxSpeed) const;
  };
}

#endif