[std] Use new include style for coding, fixes.

34 files changed, 348 insertions, 296 deletions

diff --git a/coding/base64.hpp b/coding/base64.hpp
index 80f6d540df..8f3e8cb678 100644
--- a/coding/base64.hpp
+++ b/coding/base64.hpp
@@ -1,9 +1,9 @@
 #pragma once
 
-#include "std/string.hpp"
+#include <string>
 
 namespace base64
 {
-string Encode(string const & bytesToEncode);
-string Decode(string const & base64CharsToDecode);
+std::string Encode(std::string const & bytesToEncode);
+std::string Decode(std::string const & base64CharsToDecode);
 }  // namespace base64
diff --git a/coding/buffer_reader.hpp b/coding/buffer_reader.hpp
index c35911a29a..8bb7c8e30f 100644
--- a/coding/buffer_reader.hpp
+++ b/coding/buffer_reader.hpp
@@ -1,8 +1,11 @@
-#include "coding/reader.hpp"
+#pragma once
 
-#include "std/shared_ptr.hpp"
-#include "std/cstring.hpp"
+#include "coding/reader.hpp"
 
+#include <cstddef>
+#include <cstdint>
+#include <cstring>
+#include <memory>
 
 /// Reader from buffer with ownership on it, but cheap copy constructor.
 class BufferReader : public Reader
@@ -24,26 +27,23 @@ public:
     memcpy(m_data.get(), p, count);
   }
 
-  inline uint64_t Size() const
-  {
-    return m_size;
-  }
+  uint64_t Size() const { return m_size; }
 
-  inline void Read(uint64_t pos, void * p, size_t size) const
+  void Read(uint64_t pos, void * p, size_t size) const
   {
     ASSERT_LESS_OR_EQUAL(pos + size, Size(), (pos, size));
     memcpy(p, m_data.get() + static_cast<size_t>(pos) + m_offset, size);
   }
 
-  inline BufferReader SubReader(uint64_t pos, uint64_t size) const
+  BufferReader SubReader(uint64_t pos, uint64_t size) const
   {
     return BufferReader(*this, pos, size);
   }
 
-  inline unique_ptr<Reader> CreateSubReader(uint64_t pos, uint64_t size) const
+  std::unique_ptr<Reader> CreateSubReader(uint64_t pos, uint64_t size) const
   {
     // Can't use make_unique with private constructor.
-    return unique_ptr<Reader>(new BufferReader(*this, pos, size));
+    return std::unique_ptr<Reader>(new BufferReader(*this, pos, size));
   }
 
 private:
@@ -69,5 +69,6 @@ private:
   {
     void operator() (char * p) { delete [] p; }
   };
-  shared_ptr<char> m_data;
+
+  std::shared_ptr<char> m_data;
 };
diff --git a/coding/coding_tests/compressed_bit_vector_test.cpp b/coding/coding_tests/compressed_bit_vector_test.cpp
index e70707fc3a..0b92970da2 100644
--- a/coding/coding_tests/compressed_bit_vector_test.cpp
+++ b/coding/coding_tests/compressed_bit_vector_test.cpp
@@ -3,9 +3,14 @@
 #include "coding/compressed_bit_vector.hpp"
 #include "coding/writer.hpp"
 
-#include "std/algorithm.hpp"
-#include "std/iterator.hpp"
-#include "std/set.hpp"
+#include <algorithm>
+#include <cstdint>
+#include <iterator>
+#include <memory>
+#include <set>
+#include <vector>
+
+using namespace std;
 
 namespace
 {
diff --git a/coding/coding_tests/dd_vector_test.cpp b/coding/coding_tests/dd_vector_test.cpp
index 56a96aab6e..ddb3672188 100644
--- a/coding/coding_tests/dd_vector_test.cpp
+++ b/coding/coding_tests/dd_vector_test.cpp
@@ -3,10 +3,12 @@
 #include "coding/dd_vector.hpp"
 #include "coding/reader.hpp"
 
+#include <cstdint>
+#include <vector>
 
 UNIT_TEST(DDVector_Smoke)
 {
-  vector<uint16_t> data;
+  std::vector<uint16_t> data;
   // Push size. Big endian is used.
   data.push_back(1);
   data.push_back(2);
diff --git a/coding/coding_tests/fixed_bits_ddvector_test.cpp b/coding/coding_tests/fixed_bits_ddvector_test.cpp
index 6bf7a70d3b..0f464a944e 100644
--- a/coding/coding_tests/fixed_bits_ddvector_test.cpp
+++ b/coding/coding_tests/fixed_bits_ddvector_test.cpp
@@ -3,13 +3,15 @@
 #include "coding/fixed_bits_ddvector.hpp"
 #include "coding/writer.hpp"
 
-#include "std/initializer_list.hpp"
-#include "std/random.hpp"
+#include <cstdint>
+#include <initializer_list>
+#include <random>
+#include <utility>
 
+using namespace std;
 
 namespace
 {
-
 template <size_t Bits> void TestWithData(vector<uint32_t> const & lst)
 {
   using TVector = FixedBitsDDVector<Bits, MemReader>;
@@ -48,7 +50,6 @@ template <size_t Bits> void TestWithData(vector<uint32_t> const & lst)
     ++i;
   }
 }
-
 } // namespace
 
 UNIT_TEST(FixedBitsDDVector_Smoke)
diff --git a/coding/coding_tests/reader_cache_test.cpp b/coding/coding_tests/reader_cache_test.cpp
index 5b5f1f2d06..3c17b890e6 100644
--- a/coding/coding_tests/reader_cache_test.cpp
+++ b/coding/coding_tests/reader_cache_test.cpp
@@ -3,8 +3,12 @@
 #include "coding/reader_cache.hpp"
 #include "coding/reader.hpp"
 
-#include "std/algorithm.hpp"
-#include "std/random.hpp"
+#include <algorithm>
+#include <random>
+#include <string>
+#include <vector>
+
+using namespace std;
 
 namespace
 {
diff --git a/coding/coding_tests/reader_test.cpp b/coding/coding_tests/reader_test.cpp
index 0da69bb07a..337c12bb5f 100644
--- a/coding/coding_tests/reader_test.cpp
+++ b/coding/coding_tests/reader_test.cpp
@@ -7,9 +7,12 @@
 #include "coding/buffer_reader.hpp"
 #include "coding/reader_streambuf.hpp"
 
-#include "std/iostream.hpp"
-#include "std/cstring.hpp"
+#include <cstring>
+#include <iostream>
+#include <memory>
+#include <string>
 
+using namespace std;
 
 namespace
 {
@@ -95,14 +98,14 @@ UNIT_TEST(ReaderStreamBuf)
   {
     WriterStreamBuf buffer(new FileWriter(name));
     ostream s(&buffer);
-    s << "hey!" << '\n' << 1 << '\n' << 3.14 << '\n' << 0x0102030405060708ull << std::endl;
+    s << "hey!" << '\n' << 1 << '\n' << 3.14 << '\n' << 0x0102030405060708ull << endl;
   }
 
   {
     ReaderStreamBuf buffer(make_unique<FileReader>(name));
     istream s(&buffer);
 
-    std::string str;
+    string str;
     int i;
     double d;
     unsigned long long ull;
diff --git a/coding/coding_tests/reader_test.hpp b/coding/coding_tests/reader_test.hpp
index bdd00c9d10..714996c2ef 100644
--- a/coding/coding_tests/reader_test.hpp
+++ b/coding/coding_tests/reader_test.hpp
@@ -1,19 +1,22 @@
 #pragma once
+
 #include "testing/testing.hpp"
+
 #include "coding/reader.hpp"
 
+#include <string>
 
 namespace
 {
   template <class ReaderT>
-  void ReadToStringFromPos(ReaderT const & reader, string & str, uint64_t pos, size_t size)
+  void ReadToStringFromPos(ReaderT const & reader, std::string & str, uint64_t pos, size_t size)
   {
     str.resize(size);
     reader.Read(pos, &str[0], str.size());
   }
 
   template <class SourceT>
-  void ReadToStringFromSource(SourceT & source, string & str, size_t size)
+  void ReadToStringFromSource(SourceT & source, std::string & str, size_t size)
   {
     str.resize(size);
     source.Read(&str[0], str.size());
@@ -24,7 +27,7 @@ template <typename ReaderT>
 void TestReader(ReaderT const & reader)
 {
   ReaderSource<ReaderT> source(reader);
-  string d1;
+  std::string d1;
   ReadToStringFromSource(source, d1, 6);
   TEST_EQUAL(d1, "Quick ", ());
 
diff --git a/coding/coding_tests/zip_creator_test.cpp b/coding/coding_tests/zip_creator_test.cpp
index 7a5c0b5419..5ed368c7e0 100644
--- a/coding/coding_tests/zip_creator_test.cpp
+++ b/coding/coding_tests/zip_creator_test.cpp
@@ -17,7 +17,7 @@ void CreateAndTestZip(string const & filePath, string const & zipPath)
 {
   TEST(CreateZipFromPathDeflatedAndDefaultCompression(filePath, zipPath), ());
 
-  ZipFileReader::FileListT files;
+  ZipFileReader::FileList files;
   ZipFileReader::FilesList(zipPath, files);
   TEST_EQUAL(files[0].second, FileReader(filePath).Size(), ());
 
diff --git a/coding/coding_tests/zip_reader_test.cpp b/coding/coding_tests/zip_reader_test.cpp
index bb8781dfc7..fc7b5e4d3a 100644
--- a/coding/coding_tests/zip_reader_test.cpp
+++ b/coding/coding_tests/zip_reader_test.cpp
@@ -6,6 +6,11 @@
 #include "base/logging.hpp"
 #include "base/macros.hpp"
 
+#include <exception>
+#include <string>
+
+using namespace std;
+
 static char const zipBytes[] = "PK\003\004\n\0\0\0\0\0\222\226\342>\302\032"
 "x\372\005\0\0\0\005\0\0\0\b\0\034\0te"
 "st.txtUT\t\0\003\303>\017N\017"
@@ -34,7 +39,7 @@ UNIT_TEST(ZipReaderSmoke)
     r.ReadAsString(s);
     TEST_EQUAL(s, "Test\n", ("Invalid zip file contents"));
   }
-  catch (std::exception const & e)
+  catch (exception const & e)
   {
     noException = false;
     LOG(LERROR, (e.what()));
@@ -47,7 +52,7 @@ UNIT_TEST(ZipReaderSmoke)
   {
     ZipFileReader r("some_nonexisting_filename", "test.txt");
   }
-  catch (std::exception const &)
+  catch (exception const &)
   {
     noException = false;
   }
@@ -59,7 +64,7 @@ UNIT_TEST(ZipReaderSmoke)
   {
     ZipFileReader r(ZIPFILE, "test");
   }
-  catch (std::exception const &)
+  catch (exception const &)
   {
     noException = false;
   }
@@ -104,7 +109,7 @@ UNIT_TEST(ZipFilesList)
 
   try
   {
-    ZipFileReader::FileListT files;
+    ZipFileReader::FileList files;
     ZipFileReader::FilesList(ZIPFILE, files);
 
     TEST_EQUAL(files.size(), 3, ());
@@ -115,18 +120,18 @@ UNIT_TEST(ZipFilesList)
     TEST_EQUAL(files[2].first, "3.ttt", ());
     TEST_EQUAL(files[2].second, 2, ());
   }
-  catch (std::exception const & e)
+  catch (exception const & e)
   {
     TEST(false, ("Can't get list of files inside zip", e.what()));
   }
 
   try
   {
-    ZipFileReader::FileListT files;
+    ZipFileReader::FileList files;
     ZipFileReader::FilesList(ZIPFILE_INVALID, files);
     TEST(false, ("This test shouldn't be reached - exception should be thrown"));
   }
-  catch (std::exception const &)
+  catch (exception const &)
   {
   }
 
@@ -167,7 +172,7 @@ UNIT_TEST(ZipExtract)
   }
   TEST(ZipFileReader::IsZip(ZIPFILE), ("Not a zip file"));
 
-  ZipFileReader::FileListT files;
+  ZipFileReader::FileList files;
   ZipFileReader::FilesList(ZIPFILE, files);
   TEST_EQUAL(files.size(), 2, ());
 
@@ -198,7 +203,7 @@ UNIT_TEST(ZipFileSizes)
   }
   TEST(ZipFileReader::IsZip(ZIPFILE), ("Not a zip file"));
 
-  ZipFileReader::FileListT files;
+  ZipFileReader::FileList files;
   ZipFileReader::FilesList(ZIPFILE, files);
   TEST_EQUAL(files.size(), 2, ());
 
diff --git a/coding/compressed_bit_vector.cpp b/coding/compressed_bit_vector.cpp
index 33762975aa..0d6a8e3487 100644
--- a/coding/compressed_bit_vector.cpp
+++ b/coding/compressed_bit_vector.cpp
@@ -5,7 +5,9 @@
 #include "base/assert.hpp"
 #include "base/bits.hpp"
 
-#include "std/algorithm.hpp"
+#include <algorithm>
+
+using namespace std;
 
 namespace coding
 {
diff --git a/coding/compressed_bit_vector.hpp b/coding/compressed_bit_vector.hpp
index 7bc8115639..aaf7a710c0 100644
--- a/coding/compressed_bit_vector.hpp
+++ b/coding/compressed_bit_vector.hpp
@@ -7,10 +7,12 @@
 #include "base/assert.hpp"
 #include "base/ref_counted.hpp"
 
-#include "std/algorithm.hpp"
-#include "std/unique_ptr.hpp"
-#include "std/utility.hpp"
-#include "std/vector.hpp"
+#include <cstddef>
+#include <cstdint>
+#include <memory>
+#include <string>
+#include <utility>
+#include <vector>
 
 namespace coding
 {
@@ -37,18 +39,18 @@ public:
   // routines as allocating memory and choosing strategy. They all can be called only
   // once, namely in the end, when it is needed to pack the in-memory CBV into
   // a suitable representation and pass it to the caller.
-  static unique_ptr<CompressedBitVector> Intersect(CompressedBitVector const & lhs,
-                                                   CompressedBitVector const & rhs);
+  static std::unique_ptr<CompressedBitVector> Intersect(CompressedBitVector const & lhs,
+                                                        CompressedBitVector const & rhs);
 
   // Subtracts two bit vectors.
-  static unique_ptr<CompressedBitVector> Subtract(CompressedBitVector const & lhs,
-                                                  CompressedBitVector const & rhs);
+  static std::unique_ptr<CompressedBitVector> Subtract(CompressedBitVector const & lhs,
+                                                       CompressedBitVector const & rhs);
 
   // Unites two bit vectors.
-  static unique_ptr<CompressedBitVector> Union(CompressedBitVector const & lhs,
-                                               CompressedBitVector const & rhs);
+  static std::unique_ptr<CompressedBitVector> Union(CompressedBitVector const & lhs,
+                                                    CompressedBitVector const & rhs);
 
-  static bool IsEmpty(unique_ptr<CompressedBitVector> const & cbv);
+  static bool IsEmpty(std::unique_ptr<CompressedBitVector> const & cbv);
 
   static bool IsEmpty(CompressedBitVector const * cbv);
 
@@ -61,7 +63,7 @@ public:
 
   // Returns a subset of the current bit vector with first
   // min(PopCount(), |n|) set bits.
-  virtual unique_ptr<CompressedBitVector> LeaveFirstSetNBits(uint64_t n) const = 0;
+  virtual std::unique_ptr<CompressedBitVector> LeaveFirstSetNBits(uint64_t n) const = 0;
 
   // Returns the strategy used when storing this bit vector.
   virtual StorageStrategy GetStorageStrategy() const = 0;
@@ -78,10 +80,10 @@ public:
   virtual void Serialize(Writer & writer) const = 0;
 
   // Copies a bit vector and returns a pointer to the copy.
-  virtual unique_ptr<CompressedBitVector> Clone() const = 0;
+  virtual std::unique_ptr<CompressedBitVector> Clone() const = 0;
 };
 
-string DebugPrint(CompressedBitVector::StorageStrategy strat);
+std::string DebugPrint(CompressedBitVector::StorageStrategy strat);
 
 class DenseCBV : public CompressedBitVector
 {
@@ -92,11 +94,11 @@ public:
   DenseCBV() = default;
 
   // Builds a dense CBV from a list of positions of set bits.
-  explicit DenseCBV(vector<uint64_t> const & setBits);
+  explicit DenseCBV(std::vector<uint64_t> const & setBits);
 
   // Not to be confused with the constructor: the semantics
   // of the array of integers is completely different.
-  static unique_ptr<DenseCBV> BuildFromBitGroups(vector<uint64_t> && bitGroups);
+  static std::unique_ptr<DenseCBV> BuildFromBitGroups(std::vector<uint64_t> && bitGroups);
 
   size_t NumBitGroups() const { return m_bitGroups.size(); }
 
@@ -119,13 +121,13 @@ public:
   // CompressedBitVector overrides:
   uint64_t PopCount() const override;
   bool GetBit(uint64_t pos) const override;
-  unique_ptr<CompressedBitVector> LeaveFirstSetNBits(uint64_t n) const override;
+  std::unique_ptr<CompressedBitVector> LeaveFirstSetNBits(uint64_t n) const override;
   StorageStrategy GetStorageStrategy() const override;
   void Serialize(Writer & writer) const override;
-  unique_ptr<CompressedBitVector> Clone() const override;
+  std::unique_ptr<CompressedBitVector> Clone() const override;
 
 private:
-  vector<uint64_t> m_bitGroups;
+  std::vector<uint64_t> m_bitGroups;
   uint64_t m_popCount = 0;
 };
 
@@ -133,13 +135,13 @@ class SparseCBV : public CompressedBitVector
 {
 public:
   friend class CompressedBitVectorBuilder;
-  using TIterator = vector<uint64_t>::const_iterator;
+  using TIterator = std::vector<uint64_t>::const_iterator;
 
   SparseCBV() = default;
 
-  explicit SparseCBV(vector<uint64_t> const & setBits);
+  explicit SparseCBV(std::vector<uint64_t> const & setBits);
 
-  explicit SparseCBV(vector<uint64_t> && setBits);
+  explicit SparseCBV(std::vector<uint64_t> && setBits);
 
   // Returns the position of the i'th set bit.
   uint64_t Select(size_t i) const;
@@ -154,17 +156,17 @@ public:
   // CompressedBitVector overrides:
   uint64_t PopCount() const override;
   bool GetBit(uint64_t pos) const override;
-  unique_ptr<CompressedBitVector> LeaveFirstSetNBits(uint64_t n) const override;
+  std::unique_ptr<CompressedBitVector> LeaveFirstSetNBits(uint64_t n) const override;
   StorageStrategy GetStorageStrategy() const override;
   void Serialize(Writer & writer) const override;
-  unique_ptr<CompressedBitVector> Clone() const override;
+  std::unique_ptr<CompressedBitVector> Clone() const override;
 
   inline TIterator Begin() const { return m_positions.cbegin(); }
   inline TIterator End() const { return m_positions.cend(); }
 
 private:
   // 0-based positions of the set bits.
-  vector<uint64_t> m_positions;
+  std::vector<uint64_t> m_positions;
 };
 
 class CompressedBitVectorBuilder
@@ -172,18 +174,19 @@ class CompressedBitVectorBuilder
 public:
   // Chooses a strategy to store the bit vector with bits from setBits set to one
   // and returns a pointer to a class that fits best.
-  static unique_ptr<CompressedBitVector> FromBitPositions(vector<uint64_t> const & setBits);
-  static unique_ptr<CompressedBitVector> FromBitPositions(vector<uint64_t> && setBits);
+  static std::unique_ptr<CompressedBitVector> FromBitPositions(
+      std::vector<uint64_t> const & setBits);
+  static std::unique_ptr<CompressedBitVector> FromBitPositions(std::vector<uint64_t> && setBits);
 
   // Chooses a strategy to store the bit vector with bits from a bitmap obtained
   // by concatenating the elements of bitGroups.
-  static unique_ptr<CompressedBitVector> FromBitGroups(vector<uint64_t> & bitGroups);
-  static unique_ptr<CompressedBitVector> FromBitGroups(vector<uint64_t> && bitGroups);
+  static std::unique_ptr<CompressedBitVector> FromBitGroups(std::vector<uint64_t> & bitGroups);
+  static std::unique_ptr<CompressedBitVector> FromBitGroups(std::vector<uint64_t> && bitGroups);
 
   // Reads a bit vector from reader which must contain a valid
   // bit vector representation (see CompressedBitVector::Serialize for the format).
   template <typename TReader>
-  static unique_ptr<CompressedBitVector> DeserializeFromReader(TReader & reader)
+  static std::unique_ptr<CompressedBitVector> DeserializeFromReader(TReader & reader)
   {
     ReaderSource<TReader> src(reader);
     return DeserializeFromSource(src);
@@ -192,7 +195,7 @@ public:
   // Reads a bit vector from source which must contain a valid
   // bit vector representation (see CompressedBitVector::Serialize for the format).
   template <typename TSource>
-  static unique_ptr<CompressedBitVector> DeserializeFromSource(TSource & src)
+  static std::unique_ptr<CompressedBitVector> DeserializeFromSource(TSource & src)
   {
     uint8_t header = ReadPrimitiveFromSource<uint8_t>(src);
     CompressedBitVector::StorageStrategy strat =
@@ -201,18 +204,18 @@ public:
     {
     case CompressedBitVector::StorageStrategy::Dense:
     {
-      vector<uint64_t> bitGroups;
+      std::vector<uint64_t> bitGroups;
       rw::ReadVectorOfPOD(src, bitGroups);
-      return DenseCBV::BuildFromBitGroups(move(bitGroups));
+      return DenseCBV::BuildFromBitGroups(std::move(bitGroups));
     }
     case CompressedBitVector::StorageStrategy::Sparse:
     {
-      vector<uint64_t> setBits;
+      std::vector<uint64_t> setBits;
       rw::ReadVectorOfPOD(src, setBits);
-      return make_unique<SparseCBV>(move(setBits));
+      return std::make_unique<SparseCBV>(std::move(setBits));
     }
     }
-    return unique_ptr<CompressedBitVector>();
+    return std::unique_ptr<CompressedBitVector>();
   }
 };
 
diff --git a/coding/fixed_bits_ddvector.hpp b/coding/fixed_bits_ddvector.hpp
index 6a33acc0e5..5dbde6dcdb 100644
--- a/coding/fixed_bits_ddvector.hpp
+++ b/coding/fixed_bits_ddvector.hpp
@@ -6,11 +6,11 @@
 #include "reader.hpp"
 #include "write_to_sink.hpp"
 
-#include "std/algorithm.hpp"
-#include "std/unique_ptr.hpp"
-#include "std/utility.hpp"
-#include "std/vector.hpp"
-
+#include <algorithm>
+#include <memory>
+#include <type_traits>
+#include <utility>
+#include <vector>
 
 /// Disk driven vector for optimal storing small values with rare big values.
 /// Format:
@@ -32,8 +32,8 @@ template
 >
 class FixedBitsDDVector
 {
-  static_assert(is_unsigned<TSize>::value, "");
-  static_assert(is_unsigned<TValue>::value, "");
+  static_assert(std::is_unsigned<TSize>::value, "");
+  static_assert(std::is_unsigned<TValue>::value, "");
   // 16 - is the maximum bits count to get all needed bits in random access within uint32_t.
   static_assert(Bits > 0, "");
   static_assert(Bits <= 16, "");
@@ -58,7 +58,7 @@ class FixedBitsDDVector
 
   static uint64_t AlignBytesCount(uint64_t count)
   {
-    return max(count, static_cast<uint64_t>(sizeof(TBlock)));
+    return std::max(count, static_cast<uint64_t>(sizeof(TBlock)));
   }
 
   static TBlock constexpr kMask = (1 << Bits) - 1;
@@ -67,7 +67,7 @@ class FixedBitsDDVector
 
   TValue FindInVector(TSize index) const
   {
-    auto const it = lower_bound(m_vector.begin(), m_vector.end(), IndexValue{index, 0});
+    auto const it = std::lower_bound(m_vector.begin(), m_vector.end(), IndexValue{index, 0});
     ASSERT(it != m_vector.end() && it->m_index == index, ());
     return it->m_value;
   }
@@ -82,15 +82,16 @@ class FixedBitsDDVector
   }
 
 public:
-  static unique_ptr<TSelf> Create(TReader const & reader)
+  static std::unique_ptr<TSelf> Create(TReader const & reader)
   {
     TSize const size = ReadPrimitiveFromPos<TSize>(reader, 0);
 
     uint64_t const off1 = sizeof(TSize);
     uint64_t const off2 = AlignBytesCount((size * Bits + CHAR_BIT - 1) / CHAR_BIT) + off1;
-    return unique_ptr<TSelf>(new TSelf(reader.SubReader(off1, off2 - off1),
-                                       reader.SubReader(off2, reader.Size() - off2),
-                                       size));
+
+    // We can not use make_unique here because contsructor is private.
+    return std::unique_ptr<TSelf>(new TSelf(reader.SubReader(off1, off2 - off1),
+                                            reader.SubReader(off2, reader.Size() - off2), size));
   }
 
   bool Get(TSize index, TValue & value) const
@@ -115,15 +116,15 @@ public:
 
   template <class TWriter> class Builder
   {
-    using TData = vector<uint8_t>;
+    using TData = std::vector<uint8_t>;
     using TempWriter = PushBackByteSink<TData>;
     using TBits = BitWriter<TempWriter>;
 
     TData m_data;
     TempWriter m_writer;
-    unique_ptr<TBits> m_bits;
+    std::unique_ptr<TBits> m_bits;
 
-    vector<IndexValue> m_excepts;
+    std::vector<IndexValue> m_excepts;
     TSize m_count = 0;
     TSize m_optCount = 0;
 
@@ -181,6 +182,6 @@ public:
     }
 
     /// @return (number of stored as-is elements, number of all elements)
-    pair<TSize, TSize> GetCount() const { return make_pair(m_optCount, m_count); }
+    std::pair<TSize, TSize> GetCount() const { return std::make_pair(m_optCount, m_count); }
   };
 };
diff --git a/coding/hex.hpp b/coding/hex.hpp
index 8dd9d7a74d..e06c3fad14 100644
--- a/coding/hex.hpp
+++ b/coding/hex.hpp
@@ -2,9 +2,10 @@
 
 #include "base/base.hpp"
 
-#include "std/string.hpp"
-#include "std/type_traits.hpp"
-
+#include <cstddef>
+#include <cstdint>
+#include <string>
+#include <type_traits>
 
 namespace impl
 {
@@ -12,9 +13,9 @@ namespace impl
   void FromHexRaw(void const * src, size_t size, void * dst);
 }
 
-inline string ToHex(const void * ptr, size_t size)
+inline std::string ToHex(const void * ptr, size_t size)
 {
-  string result;
+  std::string result;
   if (size == 0) return result;
 
   result.resize(size * 2);
@@ -24,12 +25,12 @@ inline string ToHex(const void * ptr, size_t size)
 }
 
 template <typename ContainerT>
-inline string ToHex(ContainerT const & container)
+inline std::string ToHex(ContainerT const & container)
 {
   static_assert(sizeof(*container.begin()) == 1, "");
 
   if (container.empty())
-    return string();
+    return {};
 
   return ToHex(&*container.begin(), container.end() - container.begin());
 }
@@ -37,9 +38,9 @@ inline string ToHex(ContainerT const & container)
 /// Conversion with specializations to avoid warnings
 /// @{
 template <typename IntT>
-inline string NumToHex(IntT n)
+inline std::string NumToHex(IntT n)
 {
-  static_assert(is_integral<IntT>::value, "");
+  static_assert(std::is_integral<IntT>::value, "");
 
   uint8_t buf[sizeof(n)];
 
@@ -53,40 +54,37 @@ inline string NumToHex(IntT n)
 }
 
 template <>
-inline string NumToHex<int8_t>(int8_t c)
+inline std::string NumToHex<int8_t>(int8_t c)
 {
   return ToHex(&c, sizeof(c));
 }
 
 template <>
-inline string NumToHex<uint8_t>(uint8_t c)
+inline std::string NumToHex<uint8_t>(uint8_t c)
 {
   return ToHex(&c, sizeof(c));
 }
 
 template <>
-inline string NumToHex<char>(char c)
+inline std::string NumToHex<char>(char c)
 {
   return ToHex(&c, sizeof(c));
 }
 /// @}
 
-inline string FromHex(void const * ptr, size_t size)
+inline std::string FromHex(void const * ptr, size_t size)
 {
-  string result;
+  std::string result;
   result.resize(size / 2);
   ::impl::FromHexRaw(ptr, size, &result[0]);
   return result;
 }
 
-inline string FromHex(string const & src)
-{
-  return FromHex(src.c_str(), src.size());
-}
+inline std::string FromHex(std::string const & src) { return FromHex(src.c_str(), src.size()); }
 
-inline string ByteToQuat(uint8_t n)
+inline std::string ByteToQuat(uint8_t n)
 {
-  string result;
+  std::string result;
   for (size_t i = 0; i < 4; ++i)
   {
     result += char(((n & 0xC0) >> 6) + '0');
@@ -96,9 +94,9 @@ inline string ByteToQuat(uint8_t n)
 }
 
 template <typename IntT>
-inline string NumToQuat(IntT n)
+inline std::string NumToQuat(IntT n)
 {
-  string result;
+  std::string result;
   for (size_t i = 0; i < sizeof(n); ++i)
   {
     uint8_t ub = n >> (sizeof(n) * 8 - 8);
diff --git a/coding/memory_region.hpp b/coding/memory_region.hpp
index f6c88c8036..0cf3c39794 100644
--- a/coding/memory_region.hpp
+++ b/coding/memory_region.hpp
@@ -4,9 +4,9 @@
 
 #include "base/macros.hpp"
 
-#include "std/cstdint.hpp"
-#include "std/utility.hpp"
-#include "std/vector.hpp"
+#include <cstdint>
+#include <utility>
+#include <vector>
 
 class MemoryRegion
 {
@@ -20,7 +20,9 @@ public:
 class MappedMemoryRegion : public MemoryRegion
 {
 public:
-  explicit MappedMemoryRegion(FilesMappingContainer::Handle && handle) : m_handle(move(handle)) {}
+  explicit MappedMemoryRegion(FilesMappingContainer::Handle && handle) : m_handle(std::move(handle))
+  {
+  }
 
   // MemoryRegion overrides:
   uint64_t Size() const override { return m_handle.GetSize(); }
@@ -35,16 +37,16 @@ private:
 class CopiedMemoryRegion : public MemoryRegion
 {
 public:
-  explicit CopiedMemoryRegion(vector<uint8_t> && buffer) : m_buffer(move(buffer)) {}
+  explicit CopiedMemoryRegion(std::vector<uint8_t> && buffer) : m_buffer(std::move(buffer)) {}
 
   // MemoryRegion overrides:
   uint64_t Size() const override { return m_buffer.size(); }
   uint8_t const * ImmutableData() const override { return m_buffer.data(); }
 
-  inline uint8_t * MutableData() { return m_buffer.data(); }
+  uint8_t * MutableData() { return m_buffer.data(); }
 
 private:
-  vector<uint8_t> m_buffer;
+  std::vector<uint8_t> m_buffer;
 
   DISALLOW_COPY(CopiedMemoryRegion);
 };
diff --git a/coding/mmap_reader.cpp b/coding/mmap_reader.cpp
index 53478fba0c..dd78d3103a 100644
--- a/coding/mmap_reader.cpp
+++ b/coding/mmap_reader.cpp
@@ -1,7 +1,8 @@
 #include "coding/mmap_reader.hpp"
 
 #include "std/target_os.hpp"
-#include "std/cstring.hpp"
+
+#include <cstring>
 
 // @TODO we don't support windows at the moment
 #ifndef OMIM_OS_WINDOWS
@@ -15,6 +16,8 @@
   #endif
 #endif
 
+using namespace std;
+
 class MmapReader::MmapData
 {
   int m_fd;
diff --git a/coding/mmap_reader.hpp b/coding/mmap_reader.hpp
index 8b41f66ec1..1203d01b46 100644
--- a/coding/mmap_reader.hpp
+++ b/coding/mmap_reader.hpp
@@ -2,26 +2,20 @@
 
 #include "coding/reader.hpp"
 
-#include "std/shared_ptr.hpp"
+#include <cstddef>
+#include <cstdint>
+#include <memory>
+#include <string>
 
 /// @TODO Add Windows support
 class MmapReader : public ModelReader
 {
-  typedef ModelReader base_type;
-
-  class MmapData;
-  shared_ptr<MmapData> m_data;
-  uint64_t m_offset;
-  uint64_t m_size;
-
-  MmapReader(MmapReader const & reader, uint64_t offset, uint64_t size);
-
 public:
-  explicit MmapReader(string const & fileName);
+  explicit MmapReader(std::string const & fileName);
 
   uint64_t Size() const override;
   void Read(uint64_t pos, void * p, size_t size) const override;
-  unique_ptr<Reader> CreateSubReader(uint64_t pos, uint64_t size) const override;
+  std::unique_ptr<Reader> CreateSubReader(uint64_t pos, uint64_t size) const override;
 
   /// Direct file/memory access
   uint8_t * Data() const;
@@ -29,4 +23,14 @@ public:
 protected:
   // Used in special derived readers.
   void SetOffsetAndSize(uint64_t offset, uint64_t size);
+
+private:
+  using base_type = ModelReader;
+  class MmapData;
+
+  MmapReader(MmapReader const & reader, uint64_t offset, uint64_t size);
+
+  std::shared_ptr<MmapData> m_data;
+  uint64_t m_offset;
+  uint64_t m_size;
 };
diff --git a/coding/parse_xml.hpp b/coding/parse_xml.hpp
index c4eb207a69..db00519b03 100644
--- a/coding/parse_xml.hpp
+++ b/coding/parse_xml.hpp
@@ -4,8 +4,8 @@
 
 #include "base/assert.hpp"
 
-#include "std/algorithm.hpp"
-
+#include <algorithm>
+#include <cstdint>
 
 template <typename XMLDispatcherT, typename SequenceT>
 uint64_t ParseXMLSequence(SequenceT & source, XMLDispatcherT & dispatcher, bool useCharData = false)
@@ -50,7 +50,7 @@ public:
   SequenceAdapter(SourceT & source) : m_source(source) {}
   uint64_t Read(void * p, uint64_t size)
   {
-    size_t const correctSize = static_cast<size_t>(min(size, m_source.Size()));
+    size_t const correctSize = static_cast<size_t>(std::min(size, m_source.Size()));
     m_source.Read(p, correctSize);
     return correctSize;
   }
diff --git a/coding/reader.cpp b/coding/reader.cpp
index e682e12c01..bf3cf668b0 100644
--- a/coding/reader.cpp
+++ b/coding/reader.cpp
@@ -2,7 +2,7 @@
 
 #include "base/string_utils.hpp"
 
-void Reader::ReadAsString(string & s) const
+void Reader::ReadAsString(std::string & s) const
 {
   s.clear();
   size_t const sz = static_cast<size_t>(Size());
@@ -10,15 +10,15 @@ void Reader::ReadAsString(string & s) const
   Read(0, &s[0], sz);
 }
 
-vector<uint8_t> Reader::ReadAsBytes() const
+std::vector<uint8_t> Reader::ReadAsBytes() const
 {
-  vector<uint8_t> contents;
+  std::vector<uint8_t> contents;
   contents.resize(Size());
   Read(0 /* pos */, contents.data(), contents.size());
   return contents;
 }
 
-bool Reader::IsEqual(string const & name1, string const & name2)
+bool Reader::IsEqual(std::string const & name1, std::string const & name2)
 {
 #if defined(OMIM_OS_WINDOWS)
   return strings::EqualNoCase(name1, name2);
diff --git a/coding/reader.hpp b/coding/reader.hpp
index 2c86532fce..6aa6f6101e 100644
--- a/coding/reader.hpp
+++ b/coding/reader.hpp
@@ -5,13 +5,15 @@
 #include "base/assert.hpp"
 #include "base/exception.hpp"
 
-#include "std/cstdint.hpp"
-#include "std/cstring.hpp"
 #include "std/shared_array.hpp"
-#include "std/shared_ptr.hpp"
-#include "std/string.hpp"
-#include "std/unique_ptr.hpp"
-#include "std/vector.hpp"
+
+#include <cstddef>
+#include <cstdint>
+#include <cstring>
+#include <memory>
+#include <string>
+#include <type_traits>
+#include <vector>
 
 // Base class for random-access Reader. Not thread-safe.
 class Reader
@@ -26,15 +28,15 @@ public:
   virtual ~Reader() {}
   virtual uint64_t Size() const = 0;
   virtual void Read(uint64_t pos, void * p, size_t size) const = 0;
-  virtual unique_ptr<Reader> CreateSubReader(uint64_t pos, uint64_t size) const = 0;
+  virtual std::unique_ptr<Reader> CreateSubReader(uint64_t pos, uint64_t size) const = 0;
 
-  void ReadAsString(string & s) const;
+  void ReadAsString(std::string & s) const;
 
   // Reads the contents of this Reader to a vector of 8-bit bytes.
   // Similar to ReadAsString but makes no assumptions about the char type.
-  vector<uint8_t> ReadAsBytes() const;
+  std::vector<uint8_t> ReadAsBytes() const;
 
-  static bool IsEqual(string const & name1, string const & name2);
+  static bool IsEqual(std::string const & name1, std::string const & name2);
 };
 
 // Reader from memory.
@@ -48,27 +50,24 @@ public:
   {
   }
 
-  inline uint64_t Size() const override
-  {
-    return m_size;
-  }
+  uint64_t Size() const override { return m_size; }
 
-  inline void Read(uint64_t pos, void * p, size_t size) const override
+  void Read(uint64_t pos, void * p, size_t size) const override
   {
     AssertPosAndSize(pos, size);
     memcpy(p, m_pData + pos, size);
   }
 
-  inline MemReaderTemplate SubReader(uint64_t pos, uint64_t size) const
+  MemReaderTemplate SubReader(uint64_t pos, uint64_t size) const
   {
     AssertPosAndSize(pos, size);
     return MemReaderTemplate(m_pData + pos, static_cast<size_t>(size));
   }
 
-  inline unique_ptr<Reader> CreateSubReader(uint64_t pos, uint64_t size) const override
+  std::unique_ptr<Reader> CreateSubReader(uint64_t pos, uint64_t size) const override
   {
     AssertPosAndSize(pos, size);
-    return make_unique<MemReaderTemplate>(m_pData + pos, static_cast<size_t>(size));
+    return std::make_unique<MemReaderTemplate>(m_pData + pos, static_cast<size_t>(size));
   }
 
 private:
@@ -107,11 +106,13 @@ template <class TReader>
 class ReaderPtr
 {
 protected:
-  shared_ptr<TReader> m_p;
+  std::shared_ptr<TReader> m_p;
 
 public:
   template <typename TReaderDerived>
-  ReaderPtr(unique_ptr<TReaderDerived> p) : m_p(move(p)) {}
+  ReaderPtr(std::unique_ptr<TReaderDerived> p) : m_p(move(p))
+  {
+  }
 
   uint64_t Size() const
   {
@@ -123,10 +124,7 @@ public:
     m_p->Read(pos, p, size);
   }
 
-  void ReadAsString(string & s) const
-  {
-    m_p->ReadAsString(s);
-  }
+  void ReadAsString(std::string & s) const { m_p->ReadAsString(s); }
 
   ReaderPtr<Reader> SubReader(uint64_t pos, uint64_t size) const
   {
@@ -139,14 +137,14 @@ public:
 // Model reader store file id as string.
 class ModelReader : public Reader
 {
-  string m_name;
+  std::string m_name;
 
 public:
-  ModelReader(string const & name) : m_name(name) {}
+  ModelReader(std::string const & name) : m_name(name) {}
 
-  virtual unique_ptr<Reader> CreateSubReader(uint64_t pos, uint64_t size) const override = 0;
+  virtual std::unique_ptr<Reader> CreateSubReader(uint64_t pos, uint64_t size) const override = 0;
 
-  inline string const & GetName() const { return m_name; }
+  std::string const & GetName() const { return m_name; }
 };
 
 // Reader pointer class for data files.
@@ -156,14 +154,17 @@ class ModelReaderPtr : public ReaderPtr<ModelReader>
 
 public:
   template <typename TReaderDerived>
-  ModelReaderPtr(unique_ptr<TReaderDerived> p) : TBase(move(p)) {}
+  ModelReaderPtr(std::unique_ptr<TReaderDerived> p) : TBase(move(p))
+  {
+  }
 
-  inline ModelReaderPtr SubReader(uint64_t pos, uint64_t size) const
+  ModelReaderPtr SubReader(uint64_t pos, uint64_t size) const
   {
-    return unique_ptr<ModelReader>(static_cast<ModelReader *>(m_p->CreateSubReader(pos, size).release()));
+    return std::unique_ptr<ModelReader>(
+        static_cast<ModelReader *>(m_p->CreateSubReader(pos, size).release()));
   }
 
-  inline string const & GetName() const { return m_p->GetName(); }
+  std::string const & GetName() const { return m_p->GetName(); }
 };
 
 // Source that reads from a reader.
diff --git a/coding/reader_streambuf.cpp b/coding/reader_streambuf.cpp
index 859af2eb70..2faef7864e 100644
--- a/coding/reader_streambuf.cpp
+++ b/coding/reader_streambuf.cpp
@@ -2,8 +2,9 @@
 #include "coding/reader.hpp"
 #include "coding/file_writer.hpp"
 
-#include "std/algorithm.hpp"
+#include <algorithm>
 
+using namespace std;
 
 ReaderStreamBuf::ReaderStreamBuf(unique_ptr<Reader> && p)
   : m_p(move(p)), m_pos(0), m_size(m_p->Size())
@@ -13,9 +14,9 @@ ReaderStreamBuf::ReaderStreamBuf(unique_ptr<Reader> && p)
 // Define destructor in .cpp due to using unique_ptr with incomplete type.
 ReaderStreamBuf::~ReaderStreamBuf() = default;
 
-std::streamsize ReaderStreamBuf::xsgetn(char_type * s, std::streamsize n)
+streamsize ReaderStreamBuf::xsgetn(char_type * s, streamsize n)
 {
-  std::streamsize const count = min(n, static_cast<std::streamsize>(m_size - m_pos));
+  streamsize const count = min(n, static_cast<streamsize>(m_size - m_pos));
   if (count > 0)
   {
     m_p->Read(m_pos, s, count);
@@ -26,7 +27,7 @@ std::streamsize ReaderStreamBuf::xsgetn(char_type * s, std::streamsize n)
 
 ReaderStreamBuf::int_type ReaderStreamBuf::underflow()
 {
-  std::streamsize s = xsgetn(m_buf, sizeof(m_buf));
+  streamsize s = xsgetn(m_buf, sizeof(m_buf));
   if (s > 0)
   {
     setg(m_buf, m_buf, m_buf + s);
@@ -44,7 +45,7 @@ WriterStreamBuf::~WriterStreamBuf()
   delete m_writer;
 }
 
-std::streamsize WriterStreamBuf::xsputn(char_type const * s, std::streamsize n)
+streamsize WriterStreamBuf::xsputn(char_type const * s, streamsize n)
 {
   m_writer->Write(s, n);
   return n;
diff --git a/coding/reader_streambuf.hpp b/coding/reader_streambuf.hpp
index a253e9531f..990286be70 100644
--- a/coding/reader_streambuf.hpp
+++ b/coding/reader_streambuf.hpp
@@ -1,8 +1,8 @@
 #pragma once
 
-#include "std/cstdint.hpp"
-#include "std/iostream.hpp"
-#include "std/unique_ptr.hpp"
+#include <cstdint>
+#include <iostream>
+#include <memory>
 
 class Reader;
 class Writer;
@@ -18,11 +18,11 @@ public:
 
 class ReaderStreamBuf : public BaseStreamBuf
 {
-  unique_ptr<Reader> m_p;
+  std::unique_ptr<Reader> m_p;
   uint64_t m_pos, m_size;
 
 public:
-  ReaderStreamBuf(unique_ptr<Reader> && p);
+  ReaderStreamBuf(std::unique_ptr<Reader> && p);
   virtual ~ReaderStreamBuf();
 
 private:
diff --git a/coding/streams_common.hpp b/coding/streams_common.hpp
index 94f45ab7d4..86c1ec7ba0 100644
--- a/coding/streams_common.hpp
+++ b/coding/streams_common.hpp
@@ -3,50 +3,51 @@
 #include "base/base.hpp"
 #include "base/assert.hpp"
 
-#include "std/string.hpp"
+#include <cstdint>
+#include <string>
 
 namespace stream
 {
-  namespace detail
-  {
-    template <class TStream>
-    void ReadString(TStream & s, string & t)
-    {
-      uint32_t count;
-      s >> count;
-      t.reserve(count);
+namespace detail
+{
+template <class TStream>
+void ReadString(TStream & s, std::string & t)
+{
+  uint32_t count;
+  s >> count;
+  t.reserve(count);
 
-      while (count > 0)
-      {
-        char c;
-        s >> c;
-        t.push_back(c);
-        --count;
-      }
-    }
+  while (count > 0)
+  {
+    char c;
+    s >> c;
+    t.push_back(c);
+    --count;
+  }
+}
 
-    template <class TStream, class TWriter>
-    void WriteString(TStream & s, TWriter & w, string const & t)
-    {
-      uint32_t const count = static_cast<uint32_t>(t.size());
-      s << count;
-      if (count > 0)
-        w.Write(t.c_str(), count);
-    }
+template <class TStream, class TWriter>
+void WriteString(TStream & s, TWriter & w, std::string const & t)
+{
+  uint32_t const count = static_cast<uint32_t>(t.size());
+  s << count;
+  if (count > 0)
+    w.Write(t.c_str(), count);
+}
 
-    template <class TStream>
-    void ReadBool(TStream & s, bool & t)
-    {
-      char tt;
-      s >> tt;
-      ASSERT(tt == 0 || tt == 1, (tt));
-      t = (tt != 0);
-    }
+template <class TStream>
+void ReadBool(TStream & s, bool & t)
+{
+  char tt;
+  s >> tt;
+  ASSERT(tt == 0 || tt == 1, (tt));
+  t = (tt != 0);
+}
 
-    template <class TStream>
-    void WriteBool(TStream & s, bool t)
-    {
-      s << char(t ? 1 : 0);
-    }
-  }
+template <class TStream>
+void WriteBool(TStream & s, bool t)
+{
+  s << char(t ? 1 : 0);
 }
+}  // namespace detail
+}  // namespace stream
diff --git a/coding/text_storage.hpp b/coding/text_storage.hpp
index 5994c9c0bf..321f055a2e 100644
--- a/coding/text_storage.hpp
+++ b/coding/text_storage.hpp
@@ -11,6 +11,7 @@
 #include <cstdint>
 #include <sstream>
 #include <string>
+#include <vector>
 
 namespace coding
 {
@@ -104,7 +105,7 @@ private:
     uint64_t m_subs = 0;    // number of strings inside the block
   };
 
-  void FlushPool(vector<uint64_t> const & lengths, string const & pool)
+  void FlushPool(std::vector<uint64_t> const & lengths, std::string const & pool)
   {
     for (auto const & length : lengths)
       WriteVarUint(m_writer, length);
@@ -117,10 +118,10 @@ private:
   uint64_t m_startOffset = 0;
   uint64_t m_dataOffset = 0;
 
-  vector<Block> m_blocks;
+  std::vector<Block> m_blocks;
 
   std::string m_pool;          // concatenated strings
-  vector<uint64_t> m_lengths;  // lengths of strings inside the |m_pool|
+  std::vector<uint64_t> m_lengths;  // lengths of strings inside the |m_pool|
 };
 
 class BlockedTextStorageIndex
diff --git a/coding/uri.cpp b/coding/uri.cpp
index 1c1dafbf9b..d9bc4f1874 100644
--- a/coding/uri.cpp
+++ b/coding/uri.cpp
@@ -1,11 +1,13 @@
 #include "coding/uri.hpp"
+
 #include "coding/url_encode.hpp"
 
 #include "base/assert.hpp"
 
+using namespace std;
+
 namespace url_scheme
 {
-
 void Uri::Init()
 {
   if (!Parse())
@@ -46,7 +48,7 @@ bool Uri::Parse()
   return true;
 }
 
-bool Uri::ForEachKeyValue(TCallback const & callback) const
+bool Uri::ForEachKeyValue(Callback const & callback) const
 {
   // parse query for keys and values
   size_t const count = m_url.size();
@@ -84,5 +86,4 @@ bool Uri::ForEachKeyValue(TCallback const & callback) const
   }
   return true;
 }
-
-}
+}  // namespace url_scheme
diff --git a/coding/uri.hpp b/coding/uri.hpp
index 8d2bae7d20..c2a4a2b002 100644
--- a/coding/uri.hpp
+++ b/coding/uri.hpp
@@ -2,36 +2,33 @@
 
 #include "base/base.hpp"
 
-#include "std/function.hpp"
-#include "std/string.hpp"
-
+#include <functional>
+#include <string>
 
 namespace url_scheme
 {
-
 // Uri in format: 'scheme://path?key1=value1&key2&key3=&key4=value4'
 class Uri
 {
 public:
-  using TCallback = function<bool(string const &, string const &)>;
+  using Callback = std::function<bool(std::string const &, std::string const &)>;
 
-  explicit Uri(string const & uri) : m_url(uri) { Init(); }
+  explicit Uri(std::string const & uri) : m_url(uri) { Init(); }
   Uri(char const * uri, size_t size) : m_url(uri, uri + size) { Init(); }
 
-  string const & GetScheme() const { return m_scheme; }
-  string const & GetPath() const { return m_path; }
+  std::string const & GetScheme() const { return m_scheme; }
+  std::string const & GetPath() const { return m_path; }
   bool IsValid() const { return !m_scheme.empty(); }
-  bool ForEachKeyValue(TCallback const & callback) const;
+  bool ForEachKeyValue(Callback const & callback) const;
 
 private:
   void Init();
   bool Parse();
 
-  string m_url;
-  string m_scheme;
-  string m_path;
+  std::string m_url;
+  std::string m_scheme;
+  std::string m_path;
 
   size_t m_queryStart;
 };
-
 }  // namespace url_scheme
diff --git a/coding/url_encode.hpp b/coding/url_encode.hpp
index 9f3264293a..06e80996d1 100644
--- a/coding/url_encode.hpp
+++ b/coding/url_encode.hpp
@@ -2,13 +2,12 @@
 
 #include "coding/hex.hpp"
 
-#include "std/string.hpp"
+#include <string>
 
-
-inline string UrlEncode(string const & rawUrl)
+inline std::string UrlEncode(std::string const & rawUrl)
 {
   size_t const count = rawUrl.size();
-  string result;
+  std::string result;
   result.reserve(count);
 
   for (size_t i = 0; i < count; ++i)
@@ -27,10 +26,10 @@ inline string UrlEncode(string const & rawUrl)
   return result;
 }
 
-inline string UrlDecode(string const & encodedUrl)
+inline std::string UrlDecode(std::string const & encodedUrl)
 {
   size_t const count = encodedUrl.size();
-  string result;
+  std::string result;
   result.reserve(count);
 
   for (size_t i = 0; i < count; ++i)
diff --git a/coding/var_record_reader.hpp b/coding/var_record_reader.hpp
index 8778885b01..0be5879ac6 100644
--- a/coding/var_record_reader.hpp
+++ b/coding/var_record_reader.hpp
@@ -1,10 +1,15 @@
 #pragma once
+
 #include "coding/byte_stream.hpp"
 #include "coding/reader.hpp"
 #include "coding/varint.hpp"
+
 #include "base/base.hpp"
-#include "std/algorithm.hpp"
-#include "std/vector.hpp"
+
+#include <algorithm>
+#include <cstdint>
+#include <string>
+#include <vector>
 
 inline uint32_t VarRecordSizeReaderVarint(ArrayByteSource & source)
 {
@@ -31,11 +36,12 @@ public:
     ASSERT_GREATER_OR_EQUAL(expectedRecordSize, 4, ());
   }
 
-  uint64_t ReadRecord(uint64_t const pos, vector<char> & buffer, uint32_t & recordOffset, uint32_t & actualSize) const
+  uint64_t ReadRecord(uint64_t const pos, std::vector<char> & buffer, uint32_t & recordOffset,
+                      uint32_t & actualSize) const
   {
     ASSERT_LESS(pos, m_ReaderSize, ());
     uint32_t const initialSize = static_cast<uint32_t>(
-        min(static_cast<uint64_t>(m_ExpectedRecordSize), m_ReaderSize - pos));
+        std::min(static_cast<uint64_t>(m_ExpectedRecordSize), m_ReaderSize - pos));
 
     if (buffer.size() < initialSize)
       buffer.resize(initialSize);
@@ -60,7 +66,7 @@ public:
   void ForEachRecord(F const & f) const
   {
     uint64_t pos = 0;
-    vector<char> buffer;
+    std::vector<char> buffer;
     while (pos < m_ReaderSize)
     {
       uint32_t offset = 0, size = 0;
@@ -72,7 +78,7 @@ public:
     ASSERT_EQUAL(pos, m_ReaderSize, ());
   }
 
-  bool IsEqual(string const & fName) const { return m_Reader.IsEqual(fName); }
+  bool IsEqual(std::string const & fName) const { return m_Reader.IsEqual(fName); }
 
 protected:
   ReaderT m_Reader;
diff --git a/coding/var_serial_vector.hpp b/coding/var_serial_vector.hpp
index b5d6773b19..170cfc7b25 100644
--- a/coding/var_serial_vector.hpp
+++ b/coding/var_serial_vector.hpp
@@ -5,9 +5,9 @@
 
 #include "base/assert.hpp"
 
-#include "std/string.hpp"
-#include "std/utility.hpp"
-
+#include <cstdint>
+#include <string>
+#include <utility>
 
 template <class WriterT> class VarSerialVectorWriter
 {
@@ -73,11 +73,11 @@ public:
   }
 
   /// Used for unit tests only. Dont't do COW in production code.
-  string Read(uint32_t i) const
+  std::string Read(uint32_t i) const
   {
-    pair<uint32_t, uint32_t> const posAsize = GetPosAndSize(i);
+    std::pair<uint32_t, uint32_t> const posAsize = GetPosAndSize(i);
 
-    string result;
+    std::string result;
     result.resize(posAsize.second);
     ReadFromPos(m_dataReader, posAsize.first, (void *)result.data(), posAsize.second);
     return result;
@@ -85,21 +85,21 @@ public:
 
   ReaderT SubReader(uint32_t i) const
   {
-    pair<uint32_t, uint32_t> const posAsize = GetPosAndSize(i);
+    std::pair<uint32_t, uint32_t> const posAsize = GetPosAndSize(i);
     return m_dataReader.SubReader(posAsize.first, posAsize.second);
   }
 
   uint64_t Size() const { return m_size; }
 
 private:
-  pair<uint32_t, uint32_t> GetPosAndSize(uint32_t i) const
+  std::pair<uint32_t, uint32_t> GetPosAndSize(uint32_t i) const
   {
     uint32_t const begin =
             i == 0 ? 0 : ReadPrimitiveFromPos<uint32_t>(m_offsetsReader, (i - 1) * sizeof(uint32_t));
     uint32_t const end = ReadPrimitiveFromPos<uint32_t>(m_offsetsReader, i * sizeof(uint32_t));
 
     ASSERT_LESS_OR_EQUAL(begin, end, ());
-    return make_pair(begin, end - begin);
+    return std::make_pair(begin, end - begin);
   }
 
 private:
diff --git a/coding/zip_creator.cpp b/coding/zip_creator.cpp
index 497eee83b4..7b68a5ac9e 100644
--- a/coding/zip_creator.cpp
+++ b/coding/zip_creator.cpp
@@ -10,12 +10,13 @@
 #include "base/logging.hpp"
 #include "base/scope_guard.hpp"
 
-#include "std/vector.hpp"
-#include "std/ctime.hpp"
-#include "std/algorithm.hpp"
+#include <algorithm>
+#include <ctime>
+#include <vector>
 
 #include "3party/minizip/zip.h"
 
+using namespace std;
 
 namespace
 {
diff --git a/coding/zip_creator.hpp b/coding/zip_creator.hpp
index 976dd3acf3..5753486937 100644
--- a/coding/zip_creator.hpp
+++ b/coding/zip_creator.hpp
@@ -1,4 +1,6 @@
+#pragma once
 
-#include "std/string.hpp"
+#include <string>
 
-bool CreateZipFromPathDeflatedAndDefaultCompression(string const & filePath, string const & zipFilePath);
+bool CreateZipFromPathDeflatedAndDefaultCompression(std::string const & filePath,
+                                                    std::string const & zipFilePath);
diff --git a/coding/zip_reader.cpp b/coding/zip_reader.cpp
index 54be8b90cc..18ee1a4cfa 100644
--- a/coding/zip_reader.cpp
+++ b/coding/zip_reader.cpp
@@ -1,14 +1,14 @@
 #include "coding/zip_reader.hpp"
 
-#include "base/scope_guard.hpp"
-#include "base/logging.hpp"
-
 #include "coding/constants.hpp"
 
-#include "std/bind.hpp"
+#include "base/logging.hpp"
+#include "base/scope_guard.hpp"
 
 #include "3party/minizip/unzip.h"
 
+using namespace std;
+
 namespace
 {
 class UnzipFileDelegate : public ZipFileReader::Delegate
@@ -70,7 +70,7 @@ ZipFileReader::ZipFileReader(string const & container, string const & file, uint
   m_uncompressedFileSize = fileInfo.uncompressed_size;
 }
 
-void ZipFileReader::FilesList(string const & zipContainer, FileListT & filesList)
+void ZipFileReader::FilesList(string const & zipContainer, FileList & filesList)
 {
   unzFile const zip = unzOpen64(zipContainer.c_str());
   if (!zip)
diff --git a/coding/zip_reader.hpp b/coding/zip_reader.hpp
index 904a778e31..162e687546 100644
--- a/coding/zip_reader.hpp
+++ b/coding/zip_reader.hpp
@@ -5,15 +5,15 @@
 
 #include "base/exception.hpp"
 
-#include "std/function.hpp"
-#include "std/utility.hpp"
-
+#include <cstddef>
+#include <cstdint>
+#include <functional>
+#include <string>
+#include <utility>
+#include <vector>
 
 class ZipFileReader : public FileReader
 {
-private:
-  uint64_t m_uncompressedFileSize;
-
 public:
   struct Delegate
   {
@@ -26,15 +26,15 @@ public:
     virtual void OnCompleted() {}
   };
 
-  typedef function<void(uint64_t, uint64_t)> ProgressFn;
+  using ProgressFn = std::function<void(uint64_t, uint64_t)>;
   /// Contains file name inside zip and it's uncompressed size
-  typedef vector<pair<string, uint32_t> > FileListT;
+  using FileList = std::vector<std::pair<std::string, uint32_t>>;
 
   DECLARE_EXCEPTION(OpenZipException, OpenException);
   DECLARE_EXCEPTION(LocateZipException, OpenException);
   DECLARE_EXCEPTION(InvalidZipException, OpenException);
 
-  ZipFileReader(string const & container, string const & file,
+  ZipFileReader(std::string const & container, std::string const & file,
                 uint32_t logPageSize = FileReader::kDefaultLogPageSize,
                 uint32_t logPageCount = FileReader::kDefaultLogPageCount);
 
@@ -42,12 +42,16 @@ public:
   uint64_t UncompressedSize() const { return m_uncompressedFileSize; }
 
   /// @warning Can also throw Writer::OpenException and Writer::WriteException
-  static void UnzipFile(string const & zipContainer, string const & fileInZip, Delegate & delegate);
-  static void UnzipFile(string const & zipContainer, string const & fileInZip,
-                        string const & outPath);
+  static void UnzipFile(std::string const & zipContainer, std::string const & fileInZip,
+                        Delegate & delegate);
+  static void UnzipFile(std::string const & zipContainer, std::string const & fileInZip,
+                        std::string const & outPath);
 
-  static void FilesList(string const & zipContainer, FileListT & filesList);
+  static void FilesList(std::string const & zipContainer, FileList & filesList);
 
   /// Quick version without exceptions
-  static bool IsZip(string const & zipContainer);
+  static bool IsZip(std::string const & zipContainer);
+
+private:
+  uint64_t m_uncompressedFileSize;
 };
diff --git a/coding/zlib.hpp b/coding/zlib.hpp
index 0f71024629..74d8cc3cb9 100644
--- a/coding/zlib.hpp
+++ b/coding/zlib.hpp
@@ -3,8 +3,9 @@
 #include "base/assert.hpp"
 #include "base/macros.hpp"
 
-#include "std/algorithm.hpp"
-#include "std/string.hpp"
+#include <algorithm>
+#include <cstddef>
+#include <string>
 
 #include "zlib.h"
 
@@ -41,7 +42,7 @@ public:
     }
 
     template <typename OutIt>
-    bool operator()(string const & s, OutIt out) const
+    bool operator()(std::string const & s, OutIt out) const
     {
       return (*this)(s.c_str(), s.size(), out);
     }
@@ -79,7 +80,7 @@ public:
     }
 
     template <typename OutIt>
-    bool operator()(string const & s, OutIt out) const
+    bool operator()(std::string const & s, OutIt out) const
     {
       return (*this)(s.c_str(), s.size(), out);
     }
@@ -106,7 +107,7 @@ private:
     void MoveOut(OutIt out)
     {
       ASSERT(IsInit(), ());
-      copy(m_buffer, m_buffer + kBufferSize - m_stream.avail_out, out);
+      std::copy(m_buffer, m_buffer + kBufferSize - m_stream.avail_out, out);
       m_stream.next_out = m_buffer;
       m_stream.avail_out = kBufferSize;
     }