Writing altitude section without intermediate files and using MemoryRegion for reading it.

3 files changed, 34 insertions, 32 deletions

diff --git a/indexer/altitude_loader.cpp b/indexer/altitude_loader.cpp
index 84ffc8a72d..6eab7b38e8 100644
--- a/indexer/altitude_loader.cpp
+++ b/indexer/altitude_loader.cpp
@@ -1,6 +1,7 @@
 #include "indexer/altitude_loader.hpp"
 
 #include "coding/reader.hpp"
+#include "coding/succinct_mapper.hpp"
 
 #include "base/logging.hpp"
 #include "base/stl_helpers.hpp"
@@ -12,18 +13,15 @@
 
 namespace
 {
-void ReadBuffer(ReaderSource<FilesContainerR::TReader> & src, vector<char> & buf)
+template<class TCont>
+void Map(size_t dataSize, ReaderSource<FilesContainerR::TReader> & src,
+         TCont & cont, unique_ptr<CopiedMemoryRegion> & region)
 {
-  uint32_t bufSz = 0;
-  src.Read(&bufSz, sizeof(bufSz));
-  if (bufSz > src.Size() + src.Pos())
-  {
-    ASSERT(false, ());
-    return;
-  }
-  buf.clear();
-  buf.resize(bufSz);
-  src.Read(buf.data(), bufSz);
+  vector<uint8_t> data(dataSize);
+  src.Read(data.data(), data.size());
+  region = make_unique<CopiedMemoryRegion>(move(data));
+  coding::MapVisitor visitor(region->ImmutableData());
+  cont.map(visitor);
 }
 } // namespace
 
@@ -43,13 +41,8 @@ AltitudeLoader::AltitudeLoader(MwmValue const & mwmValue)
     ReaderSource<FilesContainerR::TReader> src(*m_reader);
     m_header.Deserialize(src);
 
-    // Reading src_bit_vector with altitude availability information.
-    ReadBuffer(src, m_altitudeAvailabilitBuf);
-    succinct::mapper::map(m_altitudeAvailability, m_altitudeAvailabilitBuf.data());
-
-    // Reading table with altitude offsets for features.
-    ReadBuffer(src, m_featureTableBuf);
-    succinct::mapper::map(m_featureTable, m_featureTableBuf.data());
+    Map(m_header.GetAltitudeAvailabilitySize(), src, m_altitudeAvailability, m_altitudeAvailabilityRegion);
+    Map(m_header.GetFeatureTableSize(), src, m_featureTable, m_featureTableRegion);
   }
   catch (Reader::OpenException const & e)
   {
@@ -60,12 +53,12 @@ AltitudeLoader::AltitudeLoader(MwmValue const & mwmValue)
 
 bool AltitudeLoader::IsAvailable() const
 {
-  return m_header.minAltitude != kInvalidAltitude && m_header.altitudeInfoOffset != 0;
+  return m_header.minAltitude != kInvalidAltitude;
 }
 
 TAltitudes const & AltitudeLoader::GetAltitudes(uint32_t featureId, size_t pointCount) const
 {
-  if (m_header.altitudeInfoOffset == 0)
+  if (!IsAvailable())
   {
     // The version of mwm is less then version::Format::v8 or there's no altitude section in mwm.
     return m_dummy;
diff --git a/indexer/altitude_loader.hpp b/indexer/altitude_loader.hpp
index 4588e620c9..964b19bc5a 100644
--- a/indexer/altitude_loader.hpp
+++ b/indexer/altitude_loader.hpp
@@ -2,6 +2,8 @@
 #include "indexer/feature_altitude.hpp"
 #include "indexer/index.hpp"
 
+#include "coding/memory_region.hpp"
+
 #include "std/unique_ptr.hpp"
 #include "std/vector.hpp"
 
@@ -18,10 +20,12 @@ public:
   bool IsAvailable() const;
 
 private:
-  vector<char> m_altitudeAvailabilitBuf;
-  vector<char> m_featureTableBuf;
+  unique_ptr<CopiedMemoryRegion> m_altitudeAvailabilityRegion;
+  unique_ptr<CopiedMemoryRegion> m_featureTableRegion;
+
   succinct::rs_bit_vector m_altitudeAvailability;
   succinct::elias_fano m_featureTable;
+
   unique_ptr<FilesContainerR::TReader> m_reader;
   mutable map<uint32_t, TAltitudes> m_cache;
   TAltitudes const m_dummy;
diff --git a/indexer/feature_altitude.hpp b/indexer/feature_altitude.hpp
index 8cb8502501..3b225d04ee 100644
--- a/indexer/feature_altitude.hpp
+++ b/indexer/feature_altitude.hpp
@@ -1,7 +1,7 @@
 #pragma once
 #include "coding/varint.hpp"
 
-#include "base/logging.hpp"
+#include "base/assert.hpp"
 
 #include "std/cstdint.hpp"
 #include "std/limits.hpp"
@@ -24,17 +24,14 @@ struct AltitudeHeader
     Reset();
   }
 
-  AltitudeHeader(TAltitudeSectionVersion v, TAltitude min, TAltitudeSectionOffset offset)
-    : version(v), minAltitude(min), altitudeInfoOffset(offset)
-  {
-  }
-
   template <class TSink>
   void Serialize(TSink & sink) const
   {
     sink.Write(&version, sizeof(version));
     sink.Write(&minAltitude, sizeof(minAltitude));
+    sink.Write(&featureTableOffset, sizeof(featureTableOffset));
     sink.Write(&altitudeInfoOffset, sizeof(altitudeInfoOffset));
+    sink.Write(&endOffset, sizeof(endOffset));
   }
 
   template <class TSource>
@@ -42,24 +39,32 @@ struct AltitudeHeader
   {
     src.Read(&version, sizeof(version));
     src.Read(&minAltitude, sizeof(minAltitude));
+    src.Read(&featureTableOffset, sizeof(featureTableOffset));
     src.Read(&altitudeInfoOffset, sizeof(altitudeInfoOffset));
+    src.Read(&endOffset, sizeof(endOffset));
   }
 
-  static size_t GetHeaderSize()
-  {
-    return sizeof(version) + sizeof(minAltitude) + sizeof(altitudeInfoOffset);
-  }
+  // Methods below return sizes of parts of altitude section in bytes.
+  static size_t GetHeaderSize() { return sizeof(AltitudeHeader); }
+
+  size_t GetAltitudeAvailabilitySize() const { return featureTableOffset - GetHeaderSize(); }
+  size_t GetFeatureTableSize() const { return altitudeInfoOffset - featureTableOffset; }
+  size_t GetAltitudeInfo() const { return endOffset - altitudeInfoOffset; }
 
   void Reset()
   {
     version = 1;
     minAltitude = kInvalidAltitude;
+    featureTableOffset = 0;
     altitudeInfoOffset = 0;
+    endOffset = 0;
   }
 
   TAltitudeSectionVersion version;
   TAltitude minAltitude;
+  TAltitudeSectionOffset featureTableOffset;
   TAltitudeSectionOffset altitudeInfoOffset;
+  TAltitudeSectionOffset endOffset;
 };
 
 class Altitude