Review fixes.

1 files changed, 59 insertions, 54 deletions

diff --git a/coding/succinct_mapper.hpp b/coding/succinct_mapper.hpp
index 3800f3fea0..a5c288dac0 100644
--- a/coding/succinct_mapper.hpp
+++ b/coding/succinct_mapper.hpp
@@ -2,6 +2,9 @@
 
 #include "coding/endianness.hpp"
 
+#include "base/assert.hpp"
+#include "base/macros.hpp"
+
 #include "std/type_traits.hpp"
 
 #include "3party/succinct/mappable_vector.hpp"
@@ -12,67 +15,64 @@ namespace coding
 template <typename T>
 static T * Align8Ptr(T * ptr)
 {
-  uint64_t value = (reinterpret_cast<uint64_t>(ptr) + 0x7) & 0xfffffffffffffff8;
+  uint64_t const value = (reinterpret_cast<uint64_t>(ptr) + 0x7) & 0xfffffffffffffff8;
   return reinterpret_cast<T *>(value);
 }
 
-inline uint32_t NeedToAlign8(uint64_t written) { return 0x8 - (written & 0x7); }
+inline uint32_t ToAlign8(uint64_t written) { return (0x8 - (written & 0x7)) & 0x7; }
 
 class MapVisitor
 {
 public:
-  MapVisitor(uint8_t const * base) : m_base(base), m_cur(m_base) {}
+  explicit MapVisitor(uint8_t const * base) : m_base(base), m_cur(m_base) {}
 
   template <typename T>
-  typename enable_if<!is_pod<T>::value, MapVisitor &>::type operator()(
-      T & val, char const * /* friendlyName */)
+  typename enable_if<!is_pod<T>::value, MapVisitor &>::type operator()(T & val,
+                                                                       char const * /* name */)
   {
     val.map(*this);
     return *this;
   }
 
   template <typename T>
-  typename enable_if<is_pod<T>::value, MapVisitor &>::type operator()(
-      T & val, char const * /* friendlyName */)
+  typename enable_if<is_pod<T>::value, MapVisitor &>::type operator()(T & val,
+                                                                      char const * /* name */)
   {
     T const * valPtr = reinterpret_cast<T const *>(m_cur);
     val = *valPtr;
-    m_cur += sizeof(T);
 
-    m_cur = Align8Ptr(m_cur);
+    m_cur = Align8Ptr(m_cur + sizeof(T));
     return *this;
   }
 
   template <typename T>
-  MapVisitor & operator()(succinct::mapper::mappable_vector<T> & vec,
-                          char const * /* friendlyName */)
+  MapVisitor & operator()(succinct::mapper::mappable_vector<T> & vec, char const * /* name */)
   {
     vec.clear();
     (*this)(vec.m_size, "size");
-
     vec.m_data = reinterpret_cast<const T *>(m_cur);
-    size_t const bytes = vec.m_size * sizeof(T);
 
-    m_cur += bytes;
-    m_cur = Align8Ptr(m_cur);
+    m_cur = Align8Ptr(m_cur + vec.m_size * sizeof(T));
     return *this;
   }
 
-  size_t BytesRead() const { return static_cast<size_t>(m_cur - m_base); }
+  uint64_t BytesRead() const { return static_cast<uint64_t>(m_cur - m_base); }
 
 private:
   uint8_t const * const m_base;
   uint8_t const * m_cur;
+
+  DISALLOW_COPY_AND_MOVE(MapVisitor);
 };
 
 class ReverseMapVisitor
 {
 public:
-  ReverseMapVisitor(uint8_t * base) : m_base(base), m_cur(m_base) {}
+  explicit ReverseMapVisitor(uint8_t * base) : m_base(base), m_cur(m_base) {}
 
   template <typename T>
   typename enable_if<!is_pod<T>::value, ReverseMapVisitor &>::type operator()(
-      T & val, char const * /* friendlyName */)
+      T & val, char const * /* name */)
   {
     val.map(*this);
     return *this;
@@ -80,117 +80,122 @@ public:
 
   template <typename T>
   typename enable_if<is_pod<T>::value, ReverseMapVisitor &>::type operator()(
-      T & val, char const * /* friendlyName */)
+      T & val, char const * /* name */)
   {
     T * valPtr = reinterpret_cast<T *>(m_cur);
     *valPtr = ReverseByteOrder(*valPtr);
     val = *valPtr;
-    m_cur += sizeof(T);
 
-    m_cur = Align8Ptr(m_cur);
+    m_cur = Align8Ptr(m_cur + sizeof(T));
     return *this;
   }
 
   template <typename T>
   ReverseMapVisitor & operator()(succinct::mapper::mappable_vector<T> & vec,
-                                 char const * /* friendlyName */)
+                                 char const * /* name */)
   {
     vec.clear();
     (*this)(vec.m_size, "size");
 
     vec.m_data = reinterpret_cast<const T *>(m_cur);
-    for (auto const it = vec.begin(); it != vec.end(); ++it)
+    for (auto const it = vec.cbegin(); it != vec.cend(); ++it)
       *it = ReverseByteOrder(*it);
-    size_t const bytes = vec.m_size * sizeof(T);
 
-    m_cur += bytes;
-    m_cur = Align8Ptr(m_cur);
+    m_cur = Align8Ptr(m_cur + vec.m_size * sizeof(T));
     return *this;
   }
 
-  size_t BytesRead() const { return static_cast<size_t>(m_cur - m_base); }
+  uint64_t BytesRead() const { return static_cast<uint64_t>(m_cur - m_base); }
 
 private:
-  uint8_t * m_base;
+  uint8_t * const m_base;
   uint8_t * m_cur;
+
+  DISALLOW_COPY_AND_MOVE(ReverseMapVisitor);
 };
 
 template <typename TWriter>
 class FreezeVisitor
 {
 public:
-  FreezeVisitor(TWriter & writer) : m_writer(writer), m_written(0) {}
+  explicit FreezeVisitor(TWriter & writer) : m_writer(writer), m_bytesWritten(0) {}
 
   template <typename T>
-  typename enable_if<!is_pod<T>::value, FreezeVisitor &>::type operator()(
-      T & val, char const * /* friendlyName */)
+  typename enable_if<!is_pod<T>::value, FreezeVisitor &>::type operator()(T & val,
+                                                                          char const * /* name */)
   {
+    ASSERT(IsAligned(), ());
     val.map(*this);
     return *this;
   }
 
   template <typename T>
-  typename enable_if<is_pod<T>::value, FreezeVisitor &>::type operator()(
-      T & val, char const * /* friendlyName */)
+  typename enable_if<is_pod<T>::value, FreezeVisitor &>::type operator()(T & val,
+                                                                         char const * /* name */)
   {
-    m_writer.Write(reinterpret_cast<void const *>(&val), sizeof(T));
-    m_written += sizeof(T);
+    ASSERT(IsAligned(), ());
+    m_writer.Write(&val, sizeof(T));
+    m_bytesWritten += sizeof(T);
     WritePadding();
     return *this;
   }
 
   template <typename T>
-  FreezeVisitor & operator()(succinct::mapper::mappable_vector<T> & vec,
-                             char const * /* friendlyName */)
+  FreezeVisitor & operator()(succinct::mapper::mappable_vector<T> & vec, char const * /* name */)
   {
+    ASSERT(IsAligned(), ());
     (*this)(vec.m_size, "size");
 
     size_t const bytes = static_cast<size_t>(vec.m_size * sizeof(T));
-    m_writer.Write(vec.m_data, static_cast<size_t>(bytes));
-    m_written += bytes;
+    m_writer.Write(vec.m_data, bytes);
+    m_bytesWritten += bytes;
     WritePadding();
     return *this;
   }
 
-  size_t Written() const { return m_written; }
+  uint64_t BytesWritten() const { return m_bytesWritten; }
 
 private:
+  bool IsAligned() const { return ToAlign8(m_writer.Pos()) == 0; }
+
   void WritePadding()
   {
-    uint32_t const padding = NeedToAlign8(m_written);
     static uint64_t const zero = 0;
-    if (padding > 0 && padding < 8)
-    {
-      m_writer.Write(reinterpret_cast<void const *>(&zero), padding);
-      m_written += padding;
-    }
+
+    uint32_t const padding = ToAlign8(m_bytesWritten);
+    if (padding == 0)
+      return;
+    m_writer.Write(&zero, padding);
+    m_bytesWritten += padding;
   }
 
   TWriter & m_writer;
-  uint64_t m_written;
+  uint64_t m_bytesWritten;
+
+  DISALLOW_COPY_AND_MOVE(FreezeVisitor);
 };
 
 template <typename T>
-size_t Map(T & value, uint8_t const * base, char const * friendlyName = "<TOP>")
+uint64_t Map(T & value, uint8_t const * base, char const * name)
 {
   MapVisitor visitor(base);
-  visitor(value, friendlyName);
+  visitor(value, name);
   return visitor.BytesRead();
 }
 
 template <typename T>
-size_t ReverseMap(T & value, uint8_t * base, char const * friendlyName = "<TOP>")
+uint64_t ReverseMap(T & value, uint8_t * base, char const * name)
 {
   ReverseMapVisitor visitor(base);
-  visitor(value, friendlyName);
+  visitor(value, name);
   return visitor.BytesRead();
 }
 
 template <typename T, typename TWriter>
-size_t Freeze(T & val, TWriter & writer, char const * friendlyName = "<TOP>")
+uint64_t Freeze(T & val, TWriter & writer, char const * name)
 {
   FreezeVisitor<TWriter> visitor(writer);
-  visitor(val, friendlyName);
-  return visitor.Written();
+  visitor(val, name);
+  return visitor.BytesWritten();
 }
 }  // namespace coding