[coding] [compressed_varnum_vector] Cosmetic fixes.

coding/coding_tests/compressed_varnum_vector_test.cpp

@@ -7,74 +7,74 @@
 #include "../../base/pseudo_random.hpp"
 
 namespace {
-  u64 GetRand64()
+  uint64_t GetRand64()
   {
     static PseudoRNG32 g_rng;
-    u64 result = g_rng.Generate();
-    result ^= u64(g_rng.Generate()) << 32;
+    uint64_t result = g_rng.Generate();
+    result ^= uint64_t(g_rng.Generate()) << 32;
     return result;
   }
 }
 
 struct NumsSource
 {
-  NumsSource(vector<u64> const & v) : m_v(v) {}
-  u64 operator()(u64 pos) { ASSERT_LESS(pos, m_v.size(), ()); return m_v[pos]; }
+  NumsSource(vector<uint64_t> const & v) : m_v(v) {}
+  uint64_t operator()(uint64_t pos) { ASSERT_LESS(pos, m_v.size(), ()); return m_v[pos]; }
   
-  vector<u64> const & m_v;
+  vector<uint64_t> const & m_v;
 };
 
 UNIT_TEST(CompressedVarnumVector)
 {
-  u32 const NUMS_CNT = 5000;
-  u32 const MAX_NUM_BYTESIZE = 5;
-  vector<u64> nums, sums(1, 0);
-  u64 sum = 0;
-  for (u32 i = 0; i < NUMS_CNT; ++i)
+  uint32_t const NUMS_CNT = 5000;
+  uint32_t const MAX_NUM_BYTESIZE = 5;
+  vector<uint64_t> nums, sums(1, 0);
+  uint64_t sum = 0;
+  for (uint32_t i = 0; i < NUMS_CNT; ++i)
   {
-    u32 byteSize = GetRand64() % MAX_NUM_BYTESIZE + 1;
-    u64 num = GetRand64() & ((u64(1) << (byteSize * 8)) - 1);
+    uint32_t byteSize = GetRand64() % MAX_NUM_BYTESIZE + 1;
+    uint64_t num = GetRand64() & ((uint64_t(1) << (byteSize * 8)) - 1);
     nums.push_back(num);
     sum += num;
     sums.push_back(sum);
   }
-  vector<u8> encodedVector;
-  MemWriter< vector<u8> > encodedVectorWriter(encodedVector);
+  vector<uint8_t> encodedVector;
+  MemWriter< vector<uint8_t> > encodedVectorWriter(encodedVector);
   BuildCompressedVarnumVector(encodedVectorWriter, NumsSource(nums), nums.size(), true);
   MemReader reader(encodedVector.data(), encodedVector.size());
   CompressedVarnumVectorReader comprNums(reader);
   // Find by index.
-  for (u32 i = 0; i < nums.size(); ++i)
+  for (uint32_t i = 0; i < nums.size(); ++i)
   {
-    u64 sumBefore = 0;
+    uint64_t sumBefore = 0;
     comprNums.FindByIndex(i, sumBefore);
     TEST_EQUAL(sumBefore, sums[i], ());
-    u64 num = comprNums.Read();
+    uint64_t num = comprNums.Read();
     TEST_EQUAL(num, nums[i], ());
   }
   // Sequential read.
-  u64 sumBefore = 0;
+  uint64_t sumBefore = 0;
   comprNums.FindByIndex(200, sumBefore);
-  for (u32 i = 200; i < 300; ++i)
+  for (uint32_t i = 200; i < 300; ++i)
   {
-    u64 num = comprNums.Read();
+    uint64_t num = comprNums.Read();
     TEST_EQUAL(num, nums[i], ());
   }
   // Find by sum.
-  for (u32 i = 1; i < nums.size() - 1; ++i)
+  for (uint32_t i = 1; i < nums.size() - 1; ++i)
   {
     // Find strict equal sum.
     {
-      u64 sumIncl = 0, cntIncl = 0;
-      u64 num = comprNums.FindBySum(sums[i], sumIncl, cntIncl);
+      uint64_t sumIncl = 0, cntIncl = 0;
+      uint64_t num = comprNums.FindBySum(sums[i], sumIncl, cntIncl);
       TEST_EQUAL(sumIncl, sums[i], ());
       TEST_EQUAL(cntIncl, i, ());
       TEST_EQUAL(num, nums[i - 1], ());
     }
     // Find by intermediate sum (not strictly equal).
     {
-      u64 sumIncl = 0, cntIncl = 0;
-      u64 num = comprNums.FindBySum(sums[i] + 1, sumIncl, cntIncl);
+      uint64_t sumIncl = 0, cntIncl = 0;
+      uint64_t num = comprNums.FindBySum(sums[i] + 1, sumIncl, cntIncl);
       TEST_EQUAL(sumIncl, sums[i + 1], ());
       TEST_EQUAL(cntIncl, i + 1, ());
       TEST_EQUAL(num, nums[i], ());

coding/compressed_varnum_vector.hpp

@@ -4,7 +4,7 @@
 
 #pragma once
 
-#include "../std/functional.hpp"
+#include "../std/function.hpp"
 #include "../std/stdint.hpp"
 #include "../std/vector.hpp"
 
@@ -16,7 +16,7 @@ class Writer;
 uint64_t const NUM_ELEM_PER_TABLE_ENTRY = 1024;
 
 // A source of nums.
-typedef std::function<uint64_t (uint64_t pos)> NumsSourceFuncT;
+typedef function<uint64_t (uint64_t pos)> NumsSourceFuncT;
 // Builds CompressedVarnumVector based on source of numbers.
 // If supportSums is true then sums are included in the table otherwise sums are not computed.
 void BuildCompressedVarnumVector(Writer & writer, NumsSourceFuncT numsSource, uint64_t numsCnt, bool supportSums);