[base] Replaced the namespace my with base.

21 files changed, 202 insertions, 196 deletions

diff --git a/coding/bwt_coder.hpp b/coding/bwt_coder.hpp
index ca51e526b9..790300308f 100644
--- a/coding/bwt_coder.hpp
+++ b/coding/bwt_coder.hpp
@@ -9,6 +9,7 @@
 #include <algorithm>
 #include <cstdint>
 #include <iterator>
+#include <string>
 #include <vector>
 
 namespace coding
@@ -48,7 +49,7 @@ public:
   }
 
   template <typename Sink>
-  static void EncodeAndWriteBlock(Sink & sink, string const & s)
+  static void EncodeAndWriteBlock(Sink & sink, std::string const & s)
   {
     EncodeAndWriteBlock(sink, s.size(), reinterpret_cast<uint8_t const *>(s.data()));
   }
diff --git a/coding/coding_tests/file_data_test.cpp b/coding/coding_tests/file_data_test.cpp
index f610c3f072..c4399ff7ed 100644
--- a/coding/coding_tests/file_data_test.cpp
+++ b/coding/coding_tests/file_data_test.cpp
@@ -13,20 +13,20 @@ namespace
 
   void MakeFile(string const & name)
   {
-    my::FileData f(name, my::FileData::OP_WRITE_TRUNCATE);
+    base::FileData f(name, base::FileData::OP_WRITE_TRUNCATE);
     f.Write(name.c_str(), name.size());
   }
 
   void MakeFile(string const & name, size_t const size, const char c)
   {
-    my::FileData f(name, my::FileData::OP_WRITE_TRUNCATE);
+    base::FileData f(name, base::FileData::OP_WRITE_TRUNCATE);
     f.Write(string(size, c).c_str(), size);
   }
 
 #ifdef OMIM_OS_WINDOWS
   void CheckFileOK(string const & name)
   {
-    my::FileData f(name, my::FileData::OP_READ);
+    base::FileData f(name, base::FileData::OP_READ);
 
     uint64_t const size = f.Size();
     TEST_EQUAL ( size, name.size(), () );
@@ -44,18 +44,18 @@ UNIT_TEST(FileData_ApiSmoke)
   uint64_t const size = name1.size();
 
   uint64_t sz;
-  TEST(my::GetFileSize(name1, sz), ());
+  TEST(base::GetFileSize(name1, sz), ());
   TEST_EQUAL(sz, size, ());
 
-  TEST(my::RenameFileX(name1, name2), ());
+  TEST(base::RenameFileX(name1, name2), ());
 
-  TEST(!my::GetFileSize(name1, sz), ());
-  TEST(my::GetFileSize(name2, sz), ());
+  TEST(!base::GetFileSize(name1, sz), ());
+  TEST(base::GetFileSize(name2, sz), ());
   TEST_EQUAL(sz, size, ());
 
-  TEST(my::DeleteFileX(name2), ());
+  TEST(base::DeleteFileX(name2), ());
 
-  TEST(!my::GetFileSize(name2, sz), ());
+  TEST(!base::GetFileSize(name2, sz), ());
 }
 
 /*
@@ -66,7 +66,7 @@ UNIT_TEST(FileData_NoDiskSpace)
 
   try
   {
-    my::FileData f(name, my::FileData::OP_WRITE_TRUNCATE);
+    base::FileData f(name, base::FileData::OP_WRITE_TRUNCATE);
 
     for (size_t i = 0; i < 100; ++i)
       f.Write(&bytes[0], bytes.size());
@@ -76,7 +76,7 @@ UNIT_TEST(FileData_NoDiskSpace)
     LOG(LINFO, ("Writer exception catched"));
   }
 
-  (void)my::DeleteFileX(name);
+  (void)base::DeleteFileX(name);
 }
 */
 
@@ -88,31 +88,31 @@ UNIT_TEST(FileData_SharingAV_Windows)
     MakeFile(name1);
 
     // lock file, will check sharing access
-    my::FileData f1(name1, my::FileData::OP_READ);
+    base::FileData f1(name1, base::FileData::OP_READ);
 
     // try rename or delete locked file
-    TEST(!my::RenameFileX(name1, name2), ());
-    TEST(!my::DeleteFileX(name1), ());
+    TEST(!base::RenameFileX(name1, name2), ());
+    TEST(!base::DeleteFileX(name1), ());
 
     MakeFile(name2);
 
     // try rename or copy to locked file
-    TEST(!my::RenameFileX(name2, name1), ());
-    TEST(!my::CopyFileX(name2, name1), ());
+    TEST(!base::RenameFileX(name2, name1), ());
+    TEST(!base::CopyFileX(name2, name1), ());
 
     // files should be unchanged
     CheckFileOK(name1);
     CheckFileOK(name2);
 
-    //TEST(my::CopyFile(name1, name2), ());
+    //TEST(base::CopyFile(name1, name2), ());
   }
 
   // renaming to existing file is not allowed
-  TEST(!my::RenameFileX(name1, name2), ());
-  TEST(!my::RenameFileX(name2, name1), ());
+  TEST(!base::RenameFileX(name1, name2), ());
+  TEST(!base::RenameFileX(name2, name1), ());
 
-  TEST(my::DeleteFileX(name1), ());
-  TEST(my::DeleteFileX(name2), ());
+  TEST(base::DeleteFileX(name1), ());
+  TEST(base::DeleteFileX(name2), ());
 }
 #endif
 */
@@ -121,12 +121,12 @@ UNIT_TEST(Equal_Function_Test)
 {
   MakeFile(name1);
   MakeFile(name2);
-  TEST(my::IsEqualFiles(name1, name1), ());
-  TEST(my::IsEqualFiles(name2, name2), ());
-  TEST(!my::IsEqualFiles(name1, name2), ());
+  TEST(base::IsEqualFiles(name1, name1), ());
+  TEST(base::IsEqualFiles(name2, name2), ());
+  TEST(!base::IsEqualFiles(name1, name2), ());
 
-  TEST(my::DeleteFileX(name1), ());
-  TEST(my::DeleteFileX(name2), ());
+  TEST(base::DeleteFileX(name1), ());
+  TEST(base::DeleteFileX(name2), ());
 }
 
 UNIT_TEST(Equal_Function_Test_For_Big_Files)
@@ -134,40 +134,40 @@ UNIT_TEST(Equal_Function_Test_For_Big_Files)
   {
     MakeFile(name1, 1024 * 1024, 'a');
     MakeFile(name2, 1024 * 1024, 'a');
-    TEST(my::IsEqualFiles(name1, name2), ());
-    TEST(my::DeleteFileX(name1), ());
-    TEST(my::DeleteFileX(name2), ());
+    TEST(base::IsEqualFiles(name1, name2), ());
+    TEST(base::DeleteFileX(name1), ());
+    TEST(base::DeleteFileX(name2), ());
   }
   {
     MakeFile(name1, 1024 * 1024 + 512, 'a');
     MakeFile(name2, 1024 * 1024 + 512, 'a');
-    TEST(my::IsEqualFiles(name1, name2), ());
-    TEST(my::DeleteFileX(name1), ());
-    TEST(my::DeleteFileX(name2), ());
+    TEST(base::IsEqualFiles(name1, name2), ());
+    TEST(base::DeleteFileX(name1), ());
+    TEST(base::DeleteFileX(name2), ());
   }
   {
     MakeFile(name1, 1024 * 1024 + 1, 'a');
     MakeFile(name2, 1024 * 1024 + 1, 'b');
-    TEST(my::IsEqualFiles(name1, name1), ());
-    TEST(my::IsEqualFiles(name2, name2), ());
-    TEST(!my::IsEqualFiles(name1, name2), ());
-    TEST(my::DeleteFileX(name1), ());
-    TEST(my::DeleteFileX(name2), ());
+    TEST(base::IsEqualFiles(name1, name1), ());
+    TEST(base::IsEqualFiles(name2, name2), ());
+    TEST(!base::IsEqualFiles(name1, name2), ());
+    TEST(base::DeleteFileX(name1), ());
+    TEST(base::DeleteFileX(name2), ());
   }
   {
     MakeFile(name1, 1024 * 1024, 'a');
     MakeFile(name2, 1024 * 1024, 'b');
-    TEST(my::IsEqualFiles(name1, name1), ());
-    TEST(my::IsEqualFiles(name2, name2), ());
-    TEST(!my::IsEqualFiles(name1, name2), ());
-    TEST(my::DeleteFileX(name1), ());
-    TEST(my::DeleteFileX(name2), ());
+    TEST(base::IsEqualFiles(name1, name1), ());
+    TEST(base::IsEqualFiles(name2, name2), ());
+    TEST(!base::IsEqualFiles(name1, name2), ());
+    TEST(base::DeleteFileX(name1), ());
+    TEST(base::DeleteFileX(name2), ());
   }
   {
     MakeFile(name1, 1024 * 1024, 'a');
     MakeFile(name2, 1024 * 1024 + 1, 'b');
-    TEST(!my::IsEqualFiles(name1, name2), ());
-    TEST(my::DeleteFileX(name1), ());
-    TEST(my::DeleteFileX(name2), ());
+    TEST(!base::IsEqualFiles(name1, name2), ());
+    TEST(base::DeleteFileX(name1), ());
+    TEST(base::DeleteFileX(name2), ());
   }
 }
diff --git a/coding/coding_tests/file_utils_test.cpp b/coding/coding_tests/file_utils_test.cpp
index 4f28330246..5293d3608f 100644
--- a/coding/coding_tests/file_utils_test.cpp
+++ b/coding/coding_tests/file_utils_test.cpp
@@ -2,40 +2,41 @@
 
 #include "coding/file_name_utils.hpp"
 
+#include <string>
 
 UNIT_TEST(FileName_Smoke)
 {
-  string name = "/Users/xxx/Documents/test.test";
-  TEST_EQUAL(my::GetFileExtension(name), ".test", ());
-  my::GetNameFromFullPath(name);
+  std::string name = "/Users/xxx/Documents/test.test";
+  TEST_EQUAL(base::GetFileExtension(name), ".test", ());
+  base::GetNameFromFullPath(name);
   TEST_EQUAL(name, "test.test", ());
-  my::GetNameFromFullPath(name);
+  base::GetNameFromFullPath(name);
   TEST_EQUAL(name, "test.test", ());
-  my::GetNameWithoutExt(name);
+  base::GetNameWithoutExt(name);
   TEST_EQUAL(name, "test", ());
 
   name = "C:\\My Documents\\test.test";
-  TEST_EQUAL(my::GetFileExtension(name), ".test", ());
-  my::GetNameFromFullPath(name);
+  TEST_EQUAL(base::GetFileExtension(name), ".test", ());
+  base::GetNameFromFullPath(name);
   TEST_EQUAL(name, "test.test", ());
-  my::GetNameWithoutExt(name);
+  base::GetNameWithoutExt(name);
   TEST_EQUAL(name, "test", ());
 
   name = "/";
-  TEST_EQUAL(my::GetFileExtension(name), string(), ());
-  my::GetNameFromFullPath(name);
+  TEST_EQUAL(base::GetFileExtension(name), std::string(), ());
+  base::GetNameFromFullPath(name);
   TEST(name.empty(), ());
 
   name = "C:\\";
-  TEST_EQUAL(my::GetFileExtension(name), string(), ());
-  my::GetNameFromFullPath(name);
+  TEST_EQUAL(base::GetFileExtension(name), std::string(), ());
+  base::GetNameFromFullPath(name);
   TEST(name.empty(), ());
 
   name = "../test";
-  TEST_EQUAL(my::GetFileExtension(name), string(), ());
-  my::GetNameFromFullPath(name);
+  TEST_EQUAL(base::GetFileExtension(name), std::string(), ());
+  base::GetNameFromFullPath(name);
   TEST_EQUAL(name, "test", ());
-  my::GetNameWithoutExt(name);
+  base::GetNameWithoutExt(name);
   TEST_EQUAL(name, "test", ());
 }
 
@@ -45,40 +46,40 @@ UNIT_TEST(FileName_Smoke)
 
 UNIT_TEST(FileName_GetDirectory)
 {
-  TEST_EQUAL("/tmp", my::GetDirectory("/tmp/evil\\file"), ());
-  TEST_EQUAL(".", my::GetDirectory("evil\\file"), ());
+  TEST_EQUAL("/tmp", base::GetDirectory("/tmp/evil\\file"), ());
+  TEST_EQUAL(".", base::GetDirectory("evil\\file"), ());
 
-  TEST_EQUAL("/", my::GetDirectory("/somefile.txt"), ());
+  TEST_EQUAL("/", base::GetDirectory("/somefile.txt"), ());
 
-  TEST_EQUAL("/", my::GetDirectory("////somefile"), ());
-  TEST_EQUAL("a/b", my::GetDirectory("a/b///somefile.txt"), ());
+  TEST_EQUAL("/", base::GetDirectory("////somefile"), ());
+  TEST_EQUAL("a/b", base::GetDirectory("a/b///somefile.txt"), ());
 
-  TEST_EQUAL("/a/b", my::GetDirectory("/a/b/c"), ());
-  TEST_EQUAL("/a/b", my::GetDirectory("/a/b/c.txt"), ());
+  TEST_EQUAL("/a/b", base::GetDirectory("/a/b/c"), ());
+  TEST_EQUAL("/a/b", base::GetDirectory("/a/b/c.txt"), ());
 
-  TEST_EQUAL(".", my::GetDirectory("somefile.txt"), ());
-  TEST_EQUAL(".", my::GetDirectory("somefile"), ());
+  TEST_EQUAL(".", base::GetDirectory("somefile.txt"), ());
+  TEST_EQUAL(".", base::GetDirectory("somefile"), ());
 }
 
 UNIT_TEST(FilePath_Slash)
 {
-  TEST_EQUAL("/", my::AddSlashIfNeeded(""), ());
-  TEST_EQUAL("/", my::AddSlashIfNeeded("/"), ());
-  TEST_EQUAL("./", my::AddSlashIfNeeded("."), ());
-  TEST_EQUAL("data/", my::AddSlashIfNeeded("data"), ());
-  TEST_EQUAL("data/", my::AddSlashIfNeeded("data/"), ());
-  TEST_EQUAL("/data/", my::AddSlashIfNeeded("/data"), ());
-  TEST_EQUAL("/data/", my::AddSlashIfNeeded("/data/"), ());
-  TEST_EQUAL("../../data/", my::AddSlashIfNeeded("../../data"), ());
-  TEST_EQUAL("../../data/", my::AddSlashIfNeeded("../../data/"), ());
+  TEST_EQUAL("/", base::AddSlashIfNeeded(""), ());
+  TEST_EQUAL("/", base::AddSlashIfNeeded("/"), ());
+  TEST_EQUAL("./", base::AddSlashIfNeeded("."), ());
+  TEST_EQUAL("data/", base::AddSlashIfNeeded("data"), ());
+  TEST_EQUAL("data/", base::AddSlashIfNeeded("data/"), ());
+  TEST_EQUAL("/data/", base::AddSlashIfNeeded("/data"), ());
+  TEST_EQUAL("/data/", base::AddSlashIfNeeded("/data/"), ());
+  TEST_EQUAL("../../data/", base::AddSlashIfNeeded("../../data"), ());
+  TEST_EQUAL("../../data/", base::AddSlashIfNeeded("../../data/"), ());
 }
 
 UNIT_TEST(FilePath_Join)
 {
-  TEST_EQUAL("omim/strings.txt", my::JoinFoldersToPath("omim", "strings.txt"), ());
-  TEST_EQUAL("omim/strings.txt", my::JoinFoldersToPath("omim/", "strings.txt"), ());
-  TEST_EQUAL("../../omim/strings.txt", my::JoinFoldersToPath({"..", "..", "omim"}, "strings.txt"), ());
-  TEST_EQUAL("../../omim/strings.txt", my::JoinFoldersToPath({"../", "..", "omim/"}, "strings.txt"), ());
+  TEST_EQUAL("omim/strings.txt", base::JoinFoldersToPath("omim", "strings.txt"), ());
+  TEST_EQUAL("omim/strings.txt", base::JoinFoldersToPath("omim/", "strings.txt"), ());
+  TEST_EQUAL("../../omim/strings.txt", base::JoinFoldersToPath({"..", "..", "omim"}, "strings.txt"), ());
+  TEST_EQUAL("../../omim/strings.txt", base::JoinFoldersToPath({"../", "..", "omim/"}, "strings.txt"), ());
 }
 
 #endif // OMIM_OS_WINDOWS
diff --git a/coding/coding_tests/traffic_test.cpp b/coding/coding_tests/traffic_test.cpp
index 83d621ab86..acc7c01922 100644
--- a/coding/coding_tests/traffic_test.cpp
+++ b/coding/coding_tests/traffic_test.cpp
@@ -42,9 +42,9 @@ void Test(vector<TrafficGPSEncoder::DataPoint> & points)
     {
       TEST_EQUAL(points[i].m_timestamp, result[i].m_timestamp,
                  (points[i].m_timestamp, result[i].m_timestamp));
-      TEST(my::AlmostEqualAbsOrRel(points[i].m_latLon.lat, result[i].m_latLon.lat, kEps),
+      TEST(base::AlmostEqualAbsOrRel(points[i].m_latLon.lat, result[i].m_latLon.lat, kEps),
            (points[i].m_latLon.lat, result[i].m_latLon.lat));
-      TEST(my::AlmostEqualAbsOrRel(points[i].m_latLon.lon, result[i].m_latLon.lon, kEps),
+      TEST(base::AlmostEqualAbsOrRel(points[i].m_latLon.lon, result[i].m_latLon.lon, kEps),
            (points[i].m_latLon.lon, result[i].m_latLon.lon));
     }
 
diff --git a/coding/coding_tests/writer_test.cpp b/coding/coding_tests/writer_test.cpp
index 7d5277f6c2..2f9de2aacb 100644
--- a/coding/coding_tests/writer_test.cpp
+++ b/coding/coding_tests/writer_test.cpp
@@ -254,7 +254,7 @@ UNIT_TEST(FileWriter_Reserve)
 
   {
     uint64_t size;
-    TEST(my::GetFileSize(TEST_FILE, size), ());
+    TEST(base::GetFileSize(TEST_FILE, size), ());
     TEST_EQUAL(size, TEST_SIZE, ());
 
     FileWriter w(TEST_FILE, FileWriter::OP_WRITE_EXISTING);
diff --git a/coding/coding_tests/zip_creator_test.cpp b/coding/coding_tests/zip_creator_test.cpp
index 781f6ff9f4..7a5c0b5419 100644
--- a/coding/coding_tests/zip_creator_test.cpp
+++ b/coding/coding_tests/zip_creator_test.cpp
@@ -24,10 +24,10 @@ void CreateAndTestZip(string const & filePath, string const & zipPath)
   string const unzippedFile = "unzipped.tmp";
   ZipFileReader::UnzipFile(zipPath, files[0].first, unzippedFile);
 
-  TEST(my::IsEqualFiles(filePath, unzippedFile), ());
-  TEST(my::DeleteFileX(filePath), ());
-  TEST(my::DeleteFileX(zipPath), ());
-  TEST(my::DeleteFileX(unzippedFile), ());
+  TEST(base::IsEqualFiles(filePath, unzippedFile), ());
+  TEST(base::DeleteFileX(filePath), ());
+  TEST(base::DeleteFileX(zipPath), ());
+  TEST(base::DeleteFileX(unzippedFile), ());
 }
 
 }
diff --git a/coding/compressed_bit_vector.hpp b/coding/compressed_bit_vector.hpp
index 925759d83d..7bc8115639 100644
--- a/coding/compressed_bit_vector.hpp
+++ b/coding/compressed_bit_vector.hpp
@@ -14,7 +14,7 @@
 
 namespace coding
 {
-class CompressedBitVector : public my::RefCounted
+class CompressedBitVector : public base::RefCounted
 {
 public:
   enum class StorageStrategy
diff --git a/coding/file_container.cpp b/coding/file_container.cpp
index 62a30d6dc1..2e7cd1780f 100644
--- a/coding/file_container.cpp
+++ b/coding/file_container.cpp
@@ -377,7 +377,7 @@ void FilesContainerW::DeleteSection(Tag const & tag)
   }
 
   // swap files
-  if (!my::DeleteFileX(m_name) || !my::RenameFileX(m_name + ".tmp", m_name))
+  if (!base::DeleteFileX(m_name) || !base::RenameFileX(m_name + ".tmp", m_name))
     MYTHROW(RootException, ("Can't rename file", m_name, "Sharing violation or disk error!"));
 
   // do open to update m_info
diff --git a/coding/file_name_utils.cpp b/coding/file_name_utils.cpp
index 0a470f1aff..fc74539e1e 100644
--- a/coding/file_name_utils.cpp
+++ b/coding/file_name_utils.cpp
@@ -1,9 +1,10 @@
-#include "file_name_utils.hpp"
+#include "coding/file_name_utils.hpp"
 
 #include "std/target_os.hpp"
 
+using namespace std;
 
-namespace my
+namespace base
 {
 void GetNameWithoutExt(string & name)
 {
@@ -63,7 +64,7 @@ string GetNativeSeparator()
 
 string JoinFoldersToPath(const string & folder, const string & file)
 {
-  return my::AddSlashIfNeeded(folder) + file;
+  return base::AddSlashIfNeeded(folder) + file;
 }
 
 string JoinFoldersToPath(initializer_list<string> const & folders, const string & file)
@@ -84,5 +85,4 @@ string AddSlashIfNeeded(string const & path)
     return path;
   return path + sep;
 }
-
-}  // namespace my
+}  // namespace base
diff --git a/coding/file_name_utils.hpp b/coding/file_name_utils.hpp
index a7ccdd8ad1..42939f4b0a 100644
--- a/coding/file_name_utils.hpp
+++ b/coding/file_name_utils.hpp
@@ -1,45 +1,45 @@
 #pragma once
 
-#include "std/initializer_list.hpp"
-#include "std/string.hpp"
-
+#include <initializer_list>
+#include <string>
 #include <utility>
 
-namespace my
+namespace base
 {
-  /// Remove extension from file name.
-  void GetNameWithoutExt(string & name);
-  string FilenameWithoutExt(string name);
-  /// @return File extension with the dot or empty string if no extension found.
-  string GetFileExtension(string const & name);
+/// Remove extension from file name.
+void GetNameWithoutExt(std::string & name);
+std::string FilenameWithoutExt(std::string name);
+/// @return File extension with the dot or empty std::string if no extension found.
+std::string GetFileExtension(std::string const & name);
 
-  /// Get file name from full path.
-  void GetNameFromFullPath(string & name);
+/// Get file name from full path.
+void GetNameFromFullPath(std::string & name);
 
-  /// Get file name from full path without extension.
-  string GetNameFromFullPathWithoutExt(string const & path);
+/// Get file name from full path without extension.
+std::string GetNameFromFullPathWithoutExt(std::string const & path);
 
-  /// Returns all but last components of the path. After dropping the last
-  /// component, all trailing slashes are removed, unless the result is a
-  /// root directory. If the argument is a single component, returns ".".
-  string GetDirectory(string const & path);
+/// Returns all but last components of the path. After dropping the last
+/// component, all trailing slashes are removed, unless the result is a
+/// root directory. If the argument is a single component, returns ".".
+std::string GetDirectory(std::string const & path);
 
-  /// Get folder separator for specific platform
-  string GetNativeSeparator();
+/// Get folder separator for specific platform
+std::string GetNativeSeparator();
 
-  /// @deprecated use JoinPath instead.
-  string JoinFoldersToPath(const string & folder, const string & file);
-  string JoinFoldersToPath(initializer_list<string> const & folders, const string & file);
+/// @deprecated use JoinPath instead.
+std::string JoinFoldersToPath(std::string const & folder, std::string const & file);
+std::string JoinFoldersToPath(std::initializer_list<std::string> const & folders,
+                              std::string const & file);
 
-  /// Add the terminating slash to the folder path string if it's not already there.
-  string AddSlashIfNeeded(string const & path);
+/// Add the terminating slash to the folder path std::string if it's not already there.
+std::string AddSlashIfNeeded(std::string const & path);
 
-  inline std::string JoinPath(std::string const & file) { return file; }
+inline std::string JoinPath(std::string const & file) { return file; }
 
-  /// Create full path from some folder using native folders separator.
-  template<typename... Args>
-  std::string JoinPath(std::string const & folder, Args&&... args)
-  {
-    return AddSlashIfNeeded(folder) + JoinPath(std::forward<Args>(args)...);
-  }
+/// Create full path from some folder using native folders separator.
+template <typename... Args>
+std::string JoinPath(std::string const & folder, Args &&... args)
+{
+  return AddSlashIfNeeded(folder) + JoinPath(std::forward<Args>(args)...);
 }
+}  // namespace base
diff --git a/coding/file_reader.cpp b/coding/file_reader.cpp
index e19920e255..1966935e1e 100644
--- a/coding/file_reader.cpp
+++ b/coding/file_reader.cpp
@@ -17,11 +17,11 @@ using namespace std;
 
 namespace
 {
-class FileDataWithCachedSize : public my::FileData
+class FileDataWithCachedSize : public base::FileData
 {
 public:
   explicit FileDataWithCachedSize(string const & fileName)
-    : my::FileData(fileName, FileData::OP_READ), m_Size(FileData::Size())
+    : base::FileData(fileName, FileData::OP_READ), m_Size(FileData::Size())
   {
   }
 
diff --git a/coding/file_writer.cpp b/coding/file_writer.cpp
index b8f44298f9..e6d2e798a3 100644
--- a/coding/file_writer.cpp
+++ b/coding/file_writer.cpp
@@ -11,7 +11,7 @@ FileWriter::FileWriter(FileWriter && rhs)
 }
 
 FileWriter::FileWriter(string const & fileName, FileWriter::Op op, bool bTruncOnClose)
-  : m_pFileData(make_unique<my::FileData>(fileName, static_cast<my::FileData::Op>(op)))
+  : m_pFileData(make_unique<base::FileData>(fileName, static_cast<base::FileData::Op>(op)))
   , m_bTruncOnClose(bTruncOnClose)
 {
 }
@@ -73,7 +73,7 @@ void FileWriter::Reserve(uint64_t size)
 
 void FileWriter::DeleteFileX(string const & fName)
 {
-  (void)my::DeleteFileX(fName);
+  UNUSED_VALUE(base::DeleteFileX(fName));
 }
 
 void FileWriter::WritePadding(uint64_t offset, uint64_t factor)
diff --git a/coding/file_writer.hpp b/coding/file_writer.hpp
index a35d889621..86711963ef 100644
--- a/coding/file_writer.hpp
+++ b/coding/file_writer.hpp
@@ -4,9 +4,15 @@
 
 #include "base/base.hpp"
 
+#include <cstddef>
+#include <cstdint>
 #include <memory>
+#include <string>
 
-namespace my { class FileData; }
+namespace base
+{
+class FileData;
+}
 
 // FileWriter, not thread safe.
 class FileWriter : public Writer
@@ -32,7 +38,7 @@ public:
 
   FileWriter(FileWriter && rhs);
 
-  explicit FileWriter(string const & fileName,
+  explicit FileWriter(std::string const & fileName,
                       Op operation = OP_WRITE_TRUNCATE, bool bTruncOnClose = false);
   ~FileWriter() override;
 
@@ -48,13 +54,13 @@ public:
 
   void Reserve(uint64_t size);
 
-  static void DeleteFileX(string const & fName);
+  static void DeleteFileX(std::string const & fName);
 
-  string const & GetName() const;
+  std::string const & GetName() const;
 
 private:
   void WritePadding(uint64_t offset, uint64_t factor);
 
-  std::unique_ptr<my::FileData> m_pFileData;
+  std::unique_ptr<base::FileData> m_pFileData;
   bool m_bTruncOnClose;
 };
diff --git a/coding/geometry_coding.cpp b/coding/geometry_coding.cpp
index 90ba013f2b..e6e821bce8 100644
--- a/coding/geometry_coding.cpp
+++ b/coding/geometry_coding.cpp
@@ -16,14 +16,14 @@ namespace
 inline m2::PointU ClampPoint(m2::PointU const & maxPoint, m2::Point<double> const & point)
 {
   using uvalue_t = m2::PointU::value_type;
-  // return m2::PointU(my::clamp(static_cast<uvalue_t>(point.x), static_cast<uvalue_t>(0),
+  // return m2::PointU(base::clamp(static_cast<uvalue_t>(point.x), static_cast<uvalue_t>(0),
   // maxPoint.x),
-  //                  my::clamp(static_cast<uvalue_t>(point.y), static_cast<uvalue_t>(0),
+  //                  base::clamp(static_cast<uvalue_t>(point.y), static_cast<uvalue_t>(0),
   //                  maxPoint.y));
 
   return m2::PointU(
-      static_cast<uvalue_t>(my::clamp(point.x, 0.0, static_cast<double>(maxPoint.x))),
-      static_cast<uvalue_t>(my::clamp(point.y, 0.0, static_cast<double>(maxPoint.y))));
+      static_cast<uvalue_t>(base::clamp(point.x, 0.0, static_cast<double>(maxPoint.x))),
+      static_cast<uvalue_t>(base::clamp(point.y, 0.0, static_cast<double>(maxPoint.y))));
 }
 
 struct edge_less_p0
diff --git a/coding/internal/file_data.cpp b/coding/internal/file_data.cpp
index 3c3fda6195..8a8ff3df58 100644
--- a/coding/internal/file_data.cpp
+++ b/coding/internal/file_data.cpp
@@ -23,10 +23,8 @@
 #include "tizen/inc/FIo.hpp"
 #endif
 
-
-namespace my
+namespace base
 {
-
 FileData::FileData(string const & fileName, Op op)
     : m_FileName(fileName), m_Op(op)
 {
@@ -210,7 +208,7 @@ bool GetFileSize(string const & fName, uint64_t & sz)
 {
   try
   {
-    typedef my::FileData fdata_t;
+    typedef base::FileData fdata_t;
     fdata_t f(fName, fdata_t::OP_READ);
     sz = f.Size();
     return true;
@@ -321,8 +319,8 @@ bool CopyFileX(string const & fOld, string const & fNew)
 
 bool IsEqualFiles(string const & firstFile, string const & secondFile)
 {
-  my::FileData first(firstFile, my::FileData::OP_READ);
-  my::FileData second(secondFile, my::FileData::OP_READ);
+  base::FileData first(firstFile, base::FileData::OP_READ);
+  base::FileData second(secondFile, base::FileData::OP_READ);
   if (first.Size() != second.Size())
     return false;
 
@@ -348,5 +346,4 @@ bool IsEqualFiles(string const & firstFile, string const & secondFile)
 
   return true;
 }
-
-}
+}  // namespace base
diff --git a/coding/internal/file_data.hpp b/coding/internal/file_data.hpp
index 2bd4514d98..d794ac23dc 100644
--- a/coding/internal/file_data.hpp
+++ b/coding/internal/file_data.hpp
@@ -18,9 +18,8 @@ namespace Tizen
 }
 #endif
 
-
-namespace my {
-
+namespace base
+{
 class FileData: private noncopyable
 {
 public:
@@ -68,4 +67,4 @@ bool WriteToTempAndRenameToFile(string const & dest, function<bool(string const
 /// @return false if copy fails. DO NOT THROWS exceptions
 bool CopyFileX(string const & fOld, string const & fNew);
 bool IsEqualFiles(string const & firstFile, string const & secondFile);
-}
+}  // namespace base
diff --git a/coding/pointd_to_pointu.cpp b/coding/pointd_to_pointu.cpp
index 6cc75da59c..7dd2593da1 100644
--- a/coding/pointd_to_pointu.cpp
+++ b/coding/pointd_to_pointu.cpp
@@ -14,7 +14,7 @@ uint32_t DoubleToUint32(double x, double min, double max, uint32_t coordBits)
 {
   ASSERT_GREATER_OR_EQUAL(coordBits, 1, ());
   ASSERT_LESS_OR_EQUAL(coordBits, 32, ());
-  x = my::clamp(x, min, max);
+  x = base::clamp(x, min, max);
   return static_cast<uint32_t>(0.5 + (x - min) / (max - min) * bits::GetFullMask(static_cast<uint8_t>(coordBits)));
 }
 
@@ -27,8 +27,8 @@ double Uint32ToDouble(uint32_t x, double min, double max, uint32_t coordBits)
 
 m2::PointU PointDToPointU(double x, double y, uint32_t coordBits)
 {
-  x = my::clamp(x, MercatorBounds::minX, MercatorBounds::maxX);
-  y = my::clamp(y, MercatorBounds::minY, MercatorBounds::maxY);
+  x = base::clamp(x, MercatorBounds::minX, MercatorBounds::maxX);
+  y = base::clamp(y, MercatorBounds::minY, MercatorBounds::maxY);
 
   uint32_t const ix = static_cast<uint32_t>(0.5 +
                                             (x - MercatorBounds::minX) /
diff --git a/coding/reader_cache.hpp b/coding/reader_cache.hpp
index 6f2c758d26..e6bc84e6d2 100644
--- a/coding/reader_cache.hpp
+++ b/coding/reader_cache.hpp
@@ -4,27 +4,29 @@
 #include "base/cache.hpp"
 #include "base/stats.hpp"
 
-#include "std/algorithm.hpp"
-#include "std/cstring.hpp"
-#include "std/sstream.hpp"
-#include "std/vector.hpp"
-
+#include <algorithm>
+#include <cstdint>
+#include <cstring>
+#include <sstream>
+#include <string>
+#include <vector>
 
 namespace impl
 {
-
-template <bool bEnable> struct ReaderCacheStats
+template <bool Enable>
+struct ReaderCacheStats
 {
-  string GetStatsStr(uint32_t, uint32_t) const { return ""; }
-  my::NoopStats<uint32_t> m_ReadSize;
-  my::NoopStats<uint32_t> m_CacheHit;
+  std::string GetStatsStr(uint32_t, uint32_t) const { return ""; }
+  base::NoopStats<uint32_t> m_ReadSize;
+  base::NoopStats<uint32_t> m_CacheHit;
 };
 
-template <> struct ReaderCacheStats<true>
+template <>
+struct ReaderCacheStats<true>
 {
-  string GetStatsStr(uint32_t logPageSize, uint32_t pageCount) const
+  std::string GetStatsStr(uint32_t logPageSize, uint32_t pageCount) const
   {
-    ostringstream out;
+    std::ostringstream out;
     out << "LogPageSize: " << logPageSize << " PageCount: " << pageCount;
     out << " ReadSize(" << m_ReadSize.GetStatsStr() << ")";
     out << " CacheHit(" << m_CacheHit.GetStatsStr() << ")";
@@ -36,11 +38,10 @@ template <> struct ReaderCacheStats<true>
     return out.str();
   }
 
-  my::AverageStats<uint32_t> m_ReadSize;
-  my::AverageStats<uint32_t> m_CacheHit;
+  base::AverageStats<uint32_t> m_ReadSize;
+  base::AverageStats<uint32_t> m_CacheHit;
 };
-
-}
+}  // namespace impl
 
 template <class ReaderT, bool bStats = false>
 class ReaderCache
@@ -60,7 +61,7 @@ public:
     char * pDst = static_cast<char *>(p);
     uint64_t pageNum = pos >> m_LogPageSize;
     size_t const firstPageOffset = static_cast<size_t>(pos - (pageNum << m_LogPageSize));
-    size_t const firstCopySize = min(size, PageSize() - firstPageOffset);
+    size_t const firstCopySize = std::min(size, PageSize() - firstPageOffset);
     ASSERT_GREATER(firstCopySize, 0, ());
     memcpy(pDst, ReadPage(reader, pageNum) + firstPageOffset, firstCopySize);
     size -= firstCopySize;
@@ -69,7 +70,7 @@ public:
     ++pageNum;
     while (size > 0)
     {
-      size_t const copySize = min(size, PageSize());
+      size_t const copySize = std::min(size, PageSize());
       memcpy(pDst, ReadPage(reader, pageNum), copySize);
       size -= copySize;
       pos += copySize;
@@ -78,7 +79,7 @@ public:
     }
   }
 
-  string GetStatsStr() const
+  std::string GetStatsStr() const
   {
     return m_Stats.GetStatsStr(m_LogPageSize, m_Cache.GetCacheSize());
   }
@@ -89,19 +90,19 @@ private:
   inline char const * ReadPage(ReaderT & reader, uint64_t pageNum)
   {
     bool cached;
-    vector<char> & v = m_Cache.Find(pageNum, cached);
+    std::vector<char> & v = m_Cache.Find(pageNum, cached);
     m_Stats.m_CacheHit(cached ? 1 : 0);
     if (!cached)
     {
       if (v.empty())
         v.resize(PageSize());
       uint64_t const pos = pageNum << m_LogPageSize;
-      reader.Read(pos, &v[0], min(PageSize(), static_cast<size_t>(reader.Size() - pos)));
+      reader.Read(pos, &v[0], std::min(PageSize(), static_cast<size_t>(reader.Size() - pos)));
     }
     return &v[0];
   }
 
-  my::Cache<uint64_t, vector<char> > m_Cache;
+  base::Cache<uint64_t, std::vector<char> > m_Cache;
   uint32_t const m_LogPageSize;
   impl::ReaderCacheStats<bStats> m_Stats;
 };
diff --git a/coding/serdes_json.hpp b/coding/serdes_json.hpp
index bffb58d69c..67639dfac9 100644
--- a/coding/serdes_json.hpp
+++ b/coding/serdes_json.hpp
@@ -12,6 +12,7 @@
 #include <cstring>
 #include <memory>
 #include <type_traits>
+#include <utility>
 #include <vector>
 
 namespace coding
@@ -88,13 +89,13 @@ public:
   template <typename R, EnableIfNotIterable<R> * = nullptr, EnableIfNotEnum<R> * = nullptr>
   void operator()(R const & r, char const * name = nullptr)
   {
-    NewScopeWith(my::NewJSONObject(), name, [this, &r] { r.Visit(*this); });
+    NewScopeWith(base::NewJSONObject(), name, [this, &r] { r.Visit(*this); });
   }
 
   template <typename T, EnableIfIterable<T> * = nullptr>
   void operator()(T const & src, char const * name = nullptr)
   {
-    NewScopeWith(my::NewJSONArray(), name, [this, &src] {
+    NewScopeWith(base::NewJSONArray(), name, [this, &src] {
       for (auto const & v : src)
         (*this)(v);
     });
@@ -103,7 +104,7 @@ public:
   template <typename R>
   void operator()(std::unique_ptr<R> const & r, char const * name = nullptr)
   {
-    NewScopeWith(my::NewJSONObject(), name, [this, &r] {
+    NewScopeWith(base::NewJSONObject(), name, [this, &r] {
       CHECK(r, ());
       r->Visit(*this);
     });
@@ -112,7 +113,7 @@ public:
   template <typename R>
   void operator()(std::shared_ptr<R> const & r, char const * name = nullptr)
   {
-    NewScopeWith(my::NewJSONObject(), name, [this, &r] {
+    NewScopeWith(base::NewJSONObject(), name, [this, &r] {
       CHECK(r, ());
       r->Visit(*this);
     });
@@ -131,9 +132,9 @@ public:
 
 protected:
   template <typename Fn>
-  void NewScopeWith(my::JSONPtr json_object, char const * name, Fn && fn)
+  void NewScopeWith(base::JSONPtr json_object, char const * name, Fn && fn)
   {
-    my::JSONPtr safe_json = std::move(m_json);
+    base::JSONPtr safe_json = std::move(m_json);
     m_json = std::move(json_object);
 
     auto rollback = [this, &safe_json, name]()
@@ -153,7 +154,7 @@ protected:
     fn();
   }
 
-  my::JSONPtr m_json = nullptr;
+  base::JSONPtr m_json = nullptr;
   Sink & m_sink;
 };
 
@@ -203,7 +204,7 @@ public:
     json_t * outerContext = SaveContext(name);
 
     if (!json_is_array(m_json))
-      MYTHROW(my::Json::Exception, ("The field", name, "must contain a json array."));
+      MYTHROW(base::Json::Exception, ("The field", name, "must contain a json array."));
 
     vs.resize(json_array_size(m_json));
     for (size_t index = 0; index < vs.size(); ++index)
@@ -223,7 +224,7 @@ public:
     json_t * outerContext = SaveContext(name);
 
     if (!json_is_array(m_json))
-      MYTHROW(my::Json::Exception, ("The field", name, "must contain a json array."));
+      MYTHROW(base::Json::Exception, ("The field", name, "must contain a json array."));
 
     T tmp;
     size_t size = json_array_size(m_json);
@@ -246,12 +247,12 @@ public:
     json_t * outerContext = SaveContext(name);
 
     if (!json_is_array(m_json))
-      MYTHROW(my::Json::Exception,
+      MYTHROW(base::Json::Exception,
               ("The field", name, "must contain a json array.", json_dumps(m_json, 0)));
 
     if (N != json_array_size(m_json))
     {
-      MYTHROW(my::Json::Exception, ("The field", name, "must contain a json array of size", N,
+      MYTHROW(base::Json::Exception, ("The field", name, "must contain a json array of size", N,
                                     "but size is", json_array_size(m_json)));
     }
 
@@ -318,7 +319,7 @@ protected:
   {
     json_t * context = m_json;
     if (name)
-      m_json = my::GetJSONObligatoryField(context, name);
+      m_json = base::GetJSONObligatoryField(context, name);
     return context;
   }
 
@@ -328,7 +329,7 @@ protected:
       m_json = context;
   }
 
-  my::Json m_jsonObject;
+  base::Json m_jsonObject;
   json_t * m_json = nullptr;
 };
 }  // namespace coding
diff --git a/coding/sha1.cpp b/coding/sha1.cpp
index 7a6c2515db..a6182d497d 100644
--- a/coding/sha1.cpp
+++ b/coding/sha1.cpp
@@ -21,7 +21,7 @@ SHA1::Hash SHA1::Calculate(std::string const & filePath)
   uint32_t constexpr kFileBufferSize = 8192;
   try
   {
-    my::FileData file(filePath, my::FileData::OP_READ);
+    base::FileData file(filePath, base::FileData::OP_READ);
     uint64_t const fileSize = file.Size();
 
     CSHA1 sha1;
diff --git a/coding/zip_creator.cpp b/coding/zip_creator.cpp
index dca31e1674..189257aa0d 100644
--- a/coding/zip_creator.cpp
+++ b/coding/zip_creator.cpp
@@ -58,7 +58,7 @@ void CreateTMZip(tm_zip & res)
 bool CreateZipFromPathDeflatedAndDefaultCompression(string const & filePath, string const & zipFilePath)
 {
   // 2. Open zip file for writing.
-  MY_SCOPE_GUARD(outFileGuard, bind(&my::DeleteFileX, cref(zipFilePath)));
+  MY_SCOPE_GUARD(outFileGuard, bind(&base::DeleteFileX, cref(zipFilePath)));
   ZipHandle zip(zipFilePath);
   if (!zip.Handle())
     return false;
@@ -67,7 +67,7 @@ bool CreateZipFromPathDeflatedAndDefaultCompression(string const & filePath, str
   CreateTMZip(zipInfo.tmz_date);
 
   string fileName = filePath;
-  my::GetNameFromFullPath(fileName);
+  base::GetNameFromFullPath(fileName);
   if (!strings::IsASCIIString(fileName))
     fileName = "MapsMe.kml";
 
@@ -80,7 +80,7 @@ bool CreateZipFromPathDeflatedAndDefaultCompression(string const & filePath, str
   // Write source file into zip file.
   try
   {
-    my::FileData file(filePath, my::FileData::OP_READ);
+    base::FileData file(filePath, base::FileData::OP_READ);
     uint64_t const fileSize = file.Size();
 
     uint64_t currSize = 0;