TypeFeature.h

Go to the documentation of this file.

#ifndef OSMSCOUT_TYPEFEATURE_H
#define OSMSCOUT_TYPEFEATURE_H
 
/*
  This source is part of the libosmscout library
  Copyright (C) 2018  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 <string>
#include <unordered_map>
#include <vector>
 
#include <osmscout/lib/CoreImportExport.h>
 
#include <osmscout/util/Locale.h>
#include <osmscout/util/TagErrorReporter.h>
 
#include <osmscout/io/FileScanner.h>
#include <osmscout/io/FileWriter.h>
 
#include <osmscout/system/Assert.h>
 
namespace osmscout {
 
  class OSMSCOUT_API FeatureValue
  {
  public:
    FeatureValue() = default;
    FeatureValue(const FeatureValue& featureValue) = default;
 
    virtual ~FeatureValue() = default;
 
    virtual FeatureValue& operator=(const FeatureValue& other); //NOSONAR
 
    virtual std::string GetLabel(const Locale &/*locale*/, size_t /*labelIndex*/) const
    {
      return "";
    }
 
    virtual bool IsFlagSet(size_t /*flagIndex*/) const
    {
      assert(false);
 
      return false;
    }

    virtual void Read(FileScanner& scanner) = 0;

    virtual void Write(FileWriter& writer) = 0;
 
    virtual bool operator==(const FeatureValue& other) const = 0; // NOSONAR
 
    virtual bool operator!=(const FeatureValue& other) const // NOSONAR
    {
      return !(*this==other);
    }
  };
 
  // Forward declaration of classes because
  // of circular dependency between them and Feature
  class FeatureValueBuffer;
  class FeatureInstance;

  class OSMSCOUT_API Feature
  {
  private:
    std::unordered_map<std::string,size_t>      labels;
    std::unordered_map<std::string,size_t>      flags;
    std::unordered_map<std::string,std::string> descriptions; 
 
  protected:
    void RegisterLabel(size_t index,
                       const std::string& labelName);
 
    void RegisterFlag(size_t index,
                      const std::string& flagName);
 
  public:
    Feature() = default;
 
    virtual ~Feature() = default;

    virtual void Initialize(TagRegistry& tagRegistry) = 0;
 
    void AddDescription(const std::string& languageCode,
                        const std::string& description);

    virtual std::string GetName() const = 0;

    virtual size_t GetValueAlignment() const
    {
      return 0;
    }

    virtual size_t GetValueSize() const
    {
      return 0;
    }

    virtual size_t GetFeatureBitCount() const
    {
      return 0;
    }

    virtual bool HasValue() const
    {
      return GetValueSize()>0;
    }

    virtual bool HasLabel() const
    {
      return !labels.empty();
    }

    virtual bool HasFlags() const
    {
      return !flags.empty();
    }

    bool GetLabelIndex(const std::string& labelName,
                       size_t& index) const;

    bool GetFlagIndex(const std::string& flagName,
                      size_t& index) const;
 
    std::string GetDescription(const std::string& languageCode) const;
 
    const std::unordered_map<std::string,std::string>& GetDescriptions() const
    {
      return descriptions;
    };
 
    virtual FeatureValue* AllocateValue(void* buffer);
 
    virtual void Parse(TagErrorReporter& reporter,
                       const TagRegistry& tagRegistry,
                       const FeatureInstance& feature,
                       const ObjectOSMRef& object,
                       const TagMap& tags,
                       FeatureValueBuffer& buffer) const = 0;
  };
 
  using FeatureRef = std::shared_ptr<Feature>;
 
  // Forward declaration of TypeInfo
  class TypeInfo;

  class OSMSCOUT_API FeatureInstance CLASS_FINAL
  {
  private:
    FeatureRef    feature;    
    const TypeInfo* type;      
    size_t        featureBit; 
    size_t        index;      
    size_t        offset;     
 
  public:
    FeatureInstance();
 
    FeatureInstance(const FeatureRef& feature,
                    const TypeInfo* type,
                    size_t featureBit,
                    size_t index,
                    size_t offset);

    FeatureRef GetFeature() const
    {
      return feature;
    }

    const TypeInfo* GetType() const
    {
      return type;
    }

    size_t GetFeatureBit() const
    {
      return featureBit;
    }

    size_t GetIndex() const
    {
      return index;
    }

    size_t GetOffset() const
    {
      return offset;
    }
  };
}
 
#endif