different file index pathes

3 files changed, 59 insertions, 46 deletions

diff --git a/indexer/features_offsets_table.cpp b/indexer/features_offsets_table.cpp
index c39a691834..96eda2fbb8 100644
--- a/indexer/features_offsets_table.cpp
+++ b/indexer/features_offsets_table.cpp
@@ -3,10 +3,12 @@
 #include "../indexer/data_header.hpp"
 #include "../indexer/features_vector.hpp"
 #include "../coding/file_writer.hpp"
+#include "../coding/internal/file_data.hpp"
+#include "../platform/platform.hpp"
 #include "../base/assert.hpp"
 #include "../base/scope_guard.hpp"
 #include "../std/string.hpp"
-#include "../defines.hpp"
+
 
 namespace feature
 {
@@ -21,10 +23,10 @@ namespace feature
   {
   }
 
-  FeaturesOffsetsTable::FeaturesOffsetsTable(FilesMappingContainer::Handle && handle)
-      : m_handle(move(handle))
+  FeaturesOffsetsTable::FeaturesOffsetsTable(string const & fileName)
   {
-    succinct::mapper::map(m_table, m_handle.GetData<char>());
+    m_pSrc = unique_ptr<MmapReader>(new MmapReader(fileName));
+    succinct::mapper::map(m_table, reinterpret_cast<char const *>(m_pSrc->Data()));
   }
 
   // static
@@ -43,26 +45,29 @@ namespace feature
   }
 
   // static
-  unique_ptr<FeaturesOffsetsTable> FeaturesOffsetsTable::Load(
-      FilesMappingContainer const & container)
+  unique_ptr<FeaturesOffsetsTable> FeaturesOffsetsTable::Load(string const & countryName)
   {
-    FilesMappingContainer::Handle handle(container.Map(FEATURES_OFFSETS_TABLE_FILE_TAG));
-    if (!handle.IsValid())
+    string const fileName  = GetIndexFileName(countryName);
+    uint64_t size;
+    if (!GetPlatform().GetFileSizeByFullPath(fileName, size))
       return unique_ptr<FeaturesOffsetsTable>();
-    return unique_ptr<FeaturesOffsetsTable>(new FeaturesOffsetsTable(std::move(handle)));
+    return unique_ptr<FeaturesOffsetsTable>(new FeaturesOffsetsTable(fileName));
   }
 
   // static
   unique_ptr<FeaturesOffsetsTable> FeaturesOffsetsTable::CreateIfNotExistsAndLoad(
-      FilesMappingContainer const & container)
+      string const & countryName)
   {
-    if (container.IsExist(FEATURES_OFFSETS_TABLE_FILE_TAG))
-      return Load(container);
-
-    if (!container.IsExist(HEADER_FILE_TAG))
+    string const fileName = GetIndexFileName(countryName);
+    uint64_t size;
+    if (GetPlatform().GetFileSizeByFullPath(fileName,size))
+      return Load(countryName);
+
+    string const mwmName = GetPlatform().WritablePathForFile(countryName + DATA_FILE_EXTENSION);
+    FilesContainerR cont(mwmName);
+    if (!cont.IsExist(HEADER_FILE_TAG))
       return unique_ptr<FeaturesOffsetsTable>();
 
-    FilesContainerR cont(container.GetName());
     DataHeader header;
     header.Load(cont.GetReader(HEADER_FILE_TAG));
 
@@ -72,17 +77,16 @@ namespace feature
       builder.PushOffset(offset);
     });
     unique_ptr<FeaturesOffsetsTable> table(Build(builder));
-    FilesContainerW writeCont(container.GetName(), FileWriter::OP_WRITE_EXISTING);
-    table->Save(writeCont);
+    table->Save(countryName);
     return table;
   }
 
-  void FeaturesOffsetsTable::Save(FilesContainerW & container)
+  void FeaturesOffsetsTable::Save(string const & countryName)
   {
-    string const fileName = container.GetFileName() + "." FEATURES_OFFSETS_TABLE_FILE_TAG;
-    MY_SCOPE_GUARD(deleteFileGuard, bind(&FileWriter::DeleteFileX, cref(fileName)));
-    succinct::mapper::freeze(m_table, fileName.c_str());
-    container.Write(fileName, FEATURES_OFFSETS_TABLE_FILE_TAG);
+    string const fileName = GetIndexFileName(countryName);
+    string const fileNameTmp = fileName + EXTENSION_TMP;
+    succinct::mapper::freeze(m_table, fileNameTmp.c_str());
+    my::RenameFileX(fileNameTmp, fileName);
   }
 
   uint64_t FeaturesOffsetsTable::GetFeatureOffset(size_t index) const
@@ -115,4 +119,9 @@ namespace feature
 
   }
 
+  string FeaturesOffsetsTable::GetIndexFileName(string const & countryName)
+  {
+    return GetPlatform().WritablePathForFileIndexes(countryName) + countryName + FEATURES_OFFSETS_TABLE_FILE_EXT;
+  }
+
 }  // namespace feature
diff --git a/indexer/features_offsets_table.hpp b/indexer/features_offsets_table.hpp
index ceff65f7e0..eb0537c6ba 100644
--- a/indexer/features_offsets_table.hpp
+++ b/indexer/features_offsets_table.hpp
@@ -1,6 +1,8 @@
 #pragma once
 
 #include "../coding/file_container.hpp"
+#include "../coding/mmap_reader.hpp"
+#include "../defines.hpp"
 #include "../std/stdint.hpp"
 #include "../std/unique_ptr.hpp"
 #include "../std/vector.hpp"
@@ -51,11 +53,10 @@ namespace feature
     /// mapped to the memory and used by internal structures of
     /// FeaturesOffsetsTable.
     ///
-    /// \param container a container with a section devoted to
-    ///                  FeaturesOffsetsTable
+    /// \param countryName a countryName to save index file to
     /// \return a pointer to an instance of FeaturesOffsetsTable or nullptr
     ///         when it's not possible to load FeaturesOffsetsTable.
-    static unique_ptr<FeaturesOffsetsTable> Load(FilesMappingContainer const & container);
+    static unique_ptr<FeaturesOffsetsTable> Load(string const & countryName);
 
     /// Loads FeaturesOffsetsTable from FilesMappingContainer. Note
     /// that some part of a file referenced by container will be
@@ -66,19 +67,18 @@ namespace feature
     ///
     /// \warning May take a lot of time if there is no precomputed section
     ///
-    /// \param container a container with a section devoted to
-    ///                  FeaturesOffsetsTable
+    /// \param countryName a country to create index to
     /// \return a pointer to an instance of FeaturesOffsetsTable or nullptr
     ///         when it's not possible to create FeaturesOffsetsTable.
-    static unique_ptr<FeaturesOffsetsTable> CreateIfNotExistsAndLoad(FilesMappingContainer const & container);
+    static unique_ptr<FeaturesOffsetsTable> CreateIfNotExistsAndLoad(string const & countryName);
 
     FeaturesOffsetsTable(FeaturesOffsetsTable const &) = delete;
     FeaturesOffsetsTable const & operator=(FeaturesOffsetsTable const &) = delete;
 
     /// Serializes current instance to a section in container.
     ///
-    /// \param container a container current instance will be serialized to
-    void Save(FilesContainerW & container);
+    /// \param countryName a name of the country to create data
+    void Save(string const & countryName);
 
     /// \param index index of a feature
     /// \return offset a feature
@@ -102,13 +102,21 @@ namespace feature
       return succinct::mapper::size_of(m_table);
     }
 
+    /// Delete temporary index file
+    static void CleanIndexFiles(string const & countryName)
+    {
+      FileWriter::DeleteFileX(GetIndexFileName(countryName));
+    }
+
   private:
+    static string GetIndexFileName(string const & countryName);
+
     FeaturesOffsetsTable(succinct::elias_fano::elias_fano_builder & builder);
 
-    FeaturesOffsetsTable(FilesMappingContainer::Handle && handle);
+    FeaturesOffsetsTable(string const &);
 
     succinct::elias_fano m_table;
 
-    FilesMappingContainer::Handle m_handle;
+    unique_ptr<MmapReader> m_pSrc;
   };
 }  // namespace feature
diff --git a/indexer/indexer_tests/features_offsets_table_test.cpp b/indexer/indexer_tests/features_offsets_table_test.cpp
index fc321bb12d..50e34e27a0 100644
--- a/indexer/indexer_tests/features_offsets_table_test.cpp
+++ b/indexer/indexer_tests/features_offsets_table_test.cpp
@@ -58,12 +58,11 @@ namespace feature
 
   UNIT_TEST(FeaturesOffsetsTable_CreateIfNotExistsAndLoad)
   {
+    string const testFileName = "minsk-pass";
     Platform & p = GetPlatform();
-    FilesContainerR baseContainer(p.GetReader("minsk-pass" DATA_FILE_EXTENSION));
-    if (baseContainer.IsExist(FEATURES_OFFSETS_TABLE_FILE_TAG))
-      FilesContainerW(baseContainer.GetFileName(), FileWriter::OP_WRITE_EXISTING).DeleteSection(FEATURES_OFFSETS_TABLE_FILE_TAG);
-    FilesMappingContainer mappingContainer(baseContainer.GetFileName());
-    unique_ptr<FeaturesOffsetsTable> table(FeaturesOffsetsTable::CreateIfNotExistsAndLoad(mappingContainer));
+    FilesContainerR baseContainer(p.GetReader(testFileName + DATA_FILE_EXTENSION));
+    FeaturesOffsetsTable::CleanIndexFiles(testFileName);
+    unique_ptr<FeaturesOffsetsTable> table(FeaturesOffsetsTable::CreateIfNotExistsAndLoad(testFileName));
     TEST(table.get(), ());
 
     feature::DataHeader header;
@@ -77,13 +76,13 @@ namespace feature
     TEST_EQUAL(builderSize, table->size(), ());
 
     table = unique_ptr<FeaturesOffsetsTable>();
-    FilesMappingContainer newReadContainer(baseContainer.GetFileName());
-    table = unique_ptr<FeaturesOffsetsTable>(FeaturesOffsetsTable::Load(newReadContainer));
+    table = unique_ptr<FeaturesOffsetsTable>(FeaturesOffsetsTable::Load(testFileName));
     TEST_EQUAL(builderSize, table->size(), ());
   }
 
   UNIT_TEST(FeaturesOffsetsTable_ReadWrite)
   {
+    string const testFileName = "test_file";
     Platform & p = GetPlatform();
     FilesContainerR baseContainer(p.GetReader("minsk-pass" DATA_FILE_EXTENSION));
 
@@ -100,7 +99,7 @@ namespace feature
     TEST(table.get(), ());
     TEST_EQUAL(builder.size(), table->size(), ());
 
-    string const testFile = p.WritablePathForFile("test_file" DATA_FILE_EXTENSION);
+    string const testFile = p.WritablePathForFile(testFileName + DATA_FILE_EXTENSION);
     MY_SCOPE_GUARD(deleteTestFileGuard, bind(&FileWriter::DeleteFileX, cref(testFile)));
 
     // Store table in a temporary data file.
@@ -111,19 +110,16 @@ namespace feature
       // table section.
       baseContainer.ForEachTag([&baseContainer, &testContainer](string const & tag)
                                {
-                                 if (tag != FEATURES_OFFSETS_TABLE_FILE_TAG)
                                    testContainer.Write(baseContainer.GetReader(tag), tag);
                                });
-      table->Save(testContainer);
+      table->Save("test_file");
       testContainer.Finish();
     }
 
     // Load table from the temporary data file.
     {
-      FilesMappingContainer testContainer(testFile);
-      MY_SCOPE_GUARD(testContainerGuard, bind(&FilesMappingContainer::Close, &testContainer));
-
-      unique_ptr<FeaturesOffsetsTable> loadedTable(FeaturesOffsetsTable::Load(testContainer));
+      MY_SCOPE_GUARD(testTableGuard, [&testFileName](){FeaturesOffsetsTable::CleanIndexFiles(testFileName);});
+      unique_ptr<FeaturesOffsetsTable> loadedTable(FeaturesOffsetsTable::Load(testFileName));
       TEST(loadedTable.get(), ());
 
       TEST_EQUAL(table->size(), loadedTable->size(), ());