FeatureReader.h

Go to the documentation of this file.

#ifndef OSMSCOUT_FEATURE_READER_H
#define OSMSCOUT_FEATURE_READER_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 <limits>
#include <vector>
 
#include <osmscout/TypeFeature.h>
#include <osmscout/TypeConfig.h>
 
namespace osmscout {

  template<class F>
  class FeatureReader
  {
  private:
    std::vector<size_t> lookupTable;
 
  public:
    explicit FeatureReader(const TypeConfig& typeConfig);

    bool GetIndex(const FeatureValueBuffer& buffer,
                  size_t& index) const;

    bool IsSet(const FeatureValueBuffer& buffer) const;
  };
 
  template<class F>
  FeatureReader<F>::FeatureReader(const TypeConfig& typeConfig)
  {
    FeatureRef feature=typeConfig.GetFeature(F::NAME);
 
    lookupTable.resize(typeConfig.GetTypeCount(),
                       std::numeric_limits<size_t>::max());
 
    for (const auto &type : typeConfig.GetTypes()) {
      size_t index;
 
      if (type->GetFeature(F::NAME,
                           index)) {
        lookupTable[type->GetIndex()]=index;
      }
    }
  }
 
  template<class F>
  bool FeatureReader<F>::GetIndex(const FeatureValueBuffer& buffer,
                                  size_t& index) const
  {
    index=lookupTable[buffer.GetType()->GetIndex()];
 
    return index!=std::numeric_limits<size_t>::max();
  }
 
  template<class F>
  bool FeatureReader<F>::IsSet(const FeatureValueBuffer& buffer) const
  {
    size_t index=lookupTable[buffer.GetType()->GetIndex()];
 
    if (index!=std::numeric_limits<size_t>::max()) {
      return buffer.HasFeature(index);
    }
 
    return false;
  }

  class OSMSCOUT_API DynamicFeatureReader CLASS_FINAL
  {
  private:
    std::string         featureName;
    std::vector<size_t> lookupTable;
 
  public:
    DynamicFeatureReader(const TypeConfig& typeConfig,
                         const Feature& feature);
 
    std::string GetFeatureName() const
    {
      return featureName;
    }
 
    bool IsSet(const FeatureValueBuffer& buffer) const;
 
    FeatureValue* GetValue(const FeatureValueBuffer& buffer) const;
  };

  template<class F, class V>
  class FeatureValueReader
  {
  private:
    std::vector<size_t> lookupTable;
 
    static_assert(std::is_base_of<Feature, F>::value, "F have to be subtype of Feature");
    static_assert(std::is_base_of<FeatureValue, V>::value, "V have to be subtype of FeatureValue");
 
  public:
    explicit FeatureValueReader(const TypeConfig& typeConfig);

    bool GetIndex(const FeatureValueBuffer& buffer,
                  size_t& index) const;

    V* GetValue(const FeatureValueBuffer& buffer) const;

    V GetValue(const FeatureValueBuffer& buffer, const V& defaultValue) const;
  };
 
  template<class F, class V>
  FeatureValueReader<F,V>::FeatureValueReader(const TypeConfig& typeConfig)
  {
    FeatureRef feature=typeConfig.GetFeature(F::NAME);
 
    assert(feature->HasValue());
 
    lookupTable.resize(typeConfig.GetTypeCount(),
                       std::numeric_limits<size_t>::max());
 
    for (const auto &type : typeConfig.GetTypes()) {
      size_t index;
 
      if (type->GetFeature(F::NAME,
                           index)) {
        lookupTable[type->GetIndex()]=index;
      }
    }
  }
 
  template<class F, class V>
  bool FeatureValueReader<F,V>::GetIndex(const FeatureValueBuffer& buffer,
                                         size_t& index) const
  {
    assert(buffer.GetType()->GetIndex() < lookupTable.size());
    index=lookupTable[buffer.GetType()->GetIndex()];
 
    return index!=std::numeric_limits<size_t>::max();
  }
 
  template<class F, class V>
  V* FeatureValueReader<F,V>::GetValue(const FeatureValueBuffer& buffer) const
  {
    assert(buffer.GetType()->GetIndex()<lookupTable.size());
    size_t index=lookupTable[buffer.GetType()->GetIndex()];
 
    if (index!=std::numeric_limits<size_t>::max() &&
        buffer.HasFeature(index)) {
      FeatureValue* val=buffer.GetValue(index);
      // Object returned from Feature::AllocateValue and V have to be the same type!
      // But it cannot be tested in compile-time, lets do it in runtime assert at least.
      assert(val==nullptr || dynamic_cast<V*>(val)!=nullptr);
      return static_cast<V*>(val);
    }
 
    return nullptr;
  }
 
  template<class F, class V>
  V FeatureValueReader<F,V>::GetValue(const FeatureValueBuffer& buffer, const V& defaultValue) const
  {
    assert(buffer.GetType()->GetIndex() < lookupTable.size());
    size_t index=lookupTable[buffer.GetType()->GetIndex()];
 
    if (index!=std::numeric_limits<size_t>::max() &&
        buffer.HasFeature(index)) {
      FeatureValue *val = buffer.GetValue(index);
      // Object returned from Feature::AllocateValue and V have to be the same type!
      // But it cannot be tested in compile-time, lets do it in runtime assert at least.
      assert(val == nullptr || dynamic_cast<V*>(val) != nullptr);
      return *static_cast<V*>(val);
    }
 
    return defaultValue;
  }
 
  template <class F, class V>
  class FeatureLabelReader
  {
  private:
    std::vector<size_t> lookupTable;
 
  public:
    explicit FeatureLabelReader(const TypeConfig& typeConfig);

    std::string GetLabel(const FeatureValueBuffer& buffer) const;
  };
 
  template<class F, class V>
  FeatureLabelReader<F,V>::FeatureLabelReader(const TypeConfig& typeConfig)
  {
    FeatureRef feature=typeConfig.GetFeature(F::NAME);
 
    assert(feature->HasLabel());
 
    lookupTable.resize(typeConfig.GetTypeCount(),
                       std::numeric_limits<size_t>::max());
 
    for (const auto &type : typeConfig.GetTypes()) {
      size_t index;
 
      if (type->GetFeature(F::NAME,
                           index)) {
        lookupTable[type->GetIndex()]=index;
      }
    }
  }
 
  template<class F, class V>
  std::string FeatureLabelReader<F,V>::GetLabel(const FeatureValueBuffer& buffer) const
  {
    size_t index=lookupTable[buffer.GetType()->GetIndex()];
 
    if (index!=std::numeric_limits<size_t>::max() &&
        buffer.HasFeature(index)) {
      auto* value=dynamic_cast<V*>(buffer.GetValue(index));
 
      if (value!=nullptr) {
        return value->GetLabel(Locale(), 0);
      }
    }
 
    return "";
  }

}
 
#endif