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

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

#include <osmscout/util/TagErrorReporter.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); // NOLINT

    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;

    virtual bool operator!=(const FeatureValue& other) const
    {
      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