Add read/write temporary feature state with additional info

generator/feature_builder.cpp

@@ -322,11 +322,11 @@ bool FeatureBuilder1::CheckValid() const
   return true;
 }
 
-void FeatureBuilder1::SerializeBase(buffer_t & data, serial::CodingParams const & params) const
+void FeatureBuilder1::SerializeBase(buffer_t & data, serial::CodingParams const & params, bool need_serialize_additional_info) const
 {
   PushBackByteSink<buffer_t> sink(data);
 
-  m_params.Write(sink);
+  m_params.Write(sink, need_serialize_additional_info);
 
   if (m_params.GetGeomType() == GEOM_POINT)
     serial::SavePoint(sink, m_center, params);
@@ -543,7 +543,7 @@ void FeatureBuilder2::Serialize(buffers_holder_t & data, serial::CodingParams co
   data.m_buffer.clear();
 
   // header data serialization
-  SerializeBase(data.m_buffer, params);
+  SerializeBase(data.m_buffer, params, false /* don't store additional info from FeatureParams*/);
 
   PushBackByteSink<buffer_t> sink(data.m_buffer);
 

generator/feature_builder.hpp

@@ -67,7 +67,7 @@ public:
   /// @name Serialization.
   //@{
   void Serialize(buffer_t & data) const;
-  void SerializeBase(buffer_t & data, serial::CodingParams const & params) const;
+  void SerializeBase(buffer_t & data, serial::CodingParams const & params, bool need_searialize_additional_info = true) const;
 
   void Deserialize(buffer_t & data);
   //@}

generator/osm2type.cpp

@@ -101,6 +101,44 @@ namespace ftype
       }
     };
 
+    class do_find_additional_info
+    {
+      size_t & m_count;
+      FeatureParams & m_params;
+
+    public:
+      typedef bool result_type;
+
+      do_find_additional_info(size_t &count, FeatureParams &params)
+      : m_count(count), m_params(params)
+      {
+        m_count = 0;
+      }
+
+      bool operator() (string const & k, string const & v)
+      {
+        ++m_count;
+
+        if (v.empty())
+          return false;
+
+        if (k == "cuisine")
+        {
+          m_params.AddAdditionalInfo(FeatureParams::ait_cuisine, v);
+        }
+        else if (k == "phone")
+        {
+          m_params.AddAdditionalInfo(FeatureParams::ait_phone_number, v);
+        }
+        else if (k == "opening_hours")
+        {
+          m_params.AddAdditionalInfo(FeatureParams::ait_open_hours, v);
+        }
+        return false;
+      }
+
+    };
+
     class do_find_name
     {
       set<string> m_savedNames;
@@ -359,6 +397,7 @@ namespace ftype
   {
     size_t count;
     for_each_tag(p, do_find_name(count, params));
+    for_each_tag(p, do_find_additional_info(count, params));
     return count;
   }
 

indexer/feature_data.cpp

@@ -168,6 +168,20 @@ bool FeatureParams::AddHouseName(string const & s)
   return false;
 }
 
+bool FeatureParams::AddAdditionalInfo(additional_info_types type, string const &s)
+{
+  if (m_additional_info[type].empty())
+  {
+    m_additional_info[type] = s;
+  }
+  else
+  {
+    m_additional_info[type] = m_additional_info[type] + ", " + s;
+  }
+  return true;
+}
+
+
 bool FeatureParams::AddHouseNumber(string const & ss)
 {
   if (!feature::IsHouseNumber(ss))

indexer/feature_data.hpp

@@ -206,6 +206,16 @@ class FeatureParams : public FeatureParamsBase
   string m_street;
 
 public:
+
+  enum additional_info_types {
+    ait_cuisine = 1,
+    ait_open_hours,
+    ait_phone_number,
+    ait_fax_number
+  };
+  typedef std::map<uint8_t, std::string> additional_info_type;
+  additional_info_type m_additional_info;
+
   typedef vector<uint32_t> types_t;
   types_t m_Types;
 
@@ -216,6 +226,9 @@ public:
   bool AddName(string const & lang, string const & s);
   bool AddHouseName(string const & s);
   bool AddHouseNumber(string const & s);
+
+  bool AddAdditionalInfo(additional_info_types type,string const &s);
+
   /// @name Used in storing full street address only.
   //@{
   void AddStreetAddress(string const & s);
@@ -230,6 +243,7 @@ public:
 
     m_Types = rhs.m_Types;
     m_street = rhs.m_street;
+    m_additional_info = rhs.m_additional_info;
   }
 
   inline bool IsValid() const { return !m_Types.empty(); }
@@ -255,7 +269,7 @@ public:
 
   uint8_t GetHeader() const;
 
-  template <class TSink> void Write(TSink & sink) const
+  template <class TSink> void Write(TSink & sink, bool need_store_additional_info = true) const
   {
     uint8_t const header = GetHeader();
 
@@ -264,10 +278,24 @@ public:
     for (size_t i = 0; i < m_Types.size(); ++i)
       WriteVarUint(sink, GetIndexForType(m_Types[i]));
 
+    if( need_store_additional_info )
+    {
+      uint8_t const ait_size = m_additional_info.size();
+      WriteToSink(sink, ait_size);
+      if (ait_size)
+      {
+        for(auto &it: m_additional_info)
+        {
+          WriteToSink(sink, uint8_t(it.first));
+          utils::WriteString(sink, it.second);
+        }
+      }
+    }
+
     BaseT::Write(sink, header);
   }
 
-  template <class TSrc> void Read(TSrc & src)
+  template <class TSrc> void Read(TSrc & src, bool need_read_additional_info = true)
   {
     using namespace feature;
 
@@ -278,6 +306,18 @@ public:
     for (size_t i = 0; i < count; ++i)
       m_Types.push_back(GetTypeForIndex(ReadVarUint<uint32_t>(src)));
 
+    if( need_read_additional_info )
+    {
+      uint8_t const ait_size = ReadPrimitiveFromSource<uint8_t>(src);
+      for(size_t i=0; i<ait_size; ++i)
+      {
+        uint8_t const key = ReadPrimitiveFromSource<uint8_t>(src);
+        std::string value;
+        utils::ReadString(src, value);
+        m_additional_info.insert(make_pair(key, value));
+      }
+    }
+
     BaseT::Read(src, header);
   }