Fix code style

2 files changed, 186 insertions, 211 deletions

diff --git a/generator/data_cache_file.hpp b/generator/data_cache_file.hpp
index 87357fcf58..742d697416 100644
--- a/generator/data_cache_file.hpp
+++ b/generator/data_cache_file.hpp
@@ -13,206 +13,189 @@
 #include "std/limits.hpp"
 #include "std/exception.hpp"
 
-
 /// Classes for reading and writing any data in file with map of offsets for
 /// fast searching in memory by some user-id.
 namespace cache
 {
-  namespace detail
-  {
-    template <class TFile, class TValue> class file_map_t
-    {
-      typedef pair<uint64_t, TValue> element_t;
-      typedef vector<element_t> id_cont_t;
-      id_cont_t m_memory;
-      TFile m_file;
-
-      static const size_t s_max_count = 1024;
-
-      struct element_less_t
-      {
-        bool operator() (element_t const & r1, element_t const & r2) const
-        {
-          return ((r1.first == r2.first) ? r1.second < r2.second : r1.first < r2.first);
-        }
-        bool operator() (element_t const & r1, uint64_t r2) const
-        {
-          return (r1.first < r2);
-        }
-        bool operator() (uint64_t r1, element_t const & r2) const
-        {
-          return (r1 < r2.first);
-        }
-      };
-
-      size_t uint64_to_size(uint64_t v)
-      {
-        ASSERT ( v < numeric_limits<size_t>::max(), ("Value to long for memory address : ", v) );
-        return static_cast<size_t>(v);
-      }
-
-    public:
-      file_map_t(string const & name) : m_file(name.c_str()) {}
-
-      string get_name() const { return m_file.GetName(); }
-
-      void flush_to_file()
-      {
-        if (!m_memory.empty())
-        {
-          m_file.Write(&m_memory[0], m_memory.size() * sizeof(element_t));
-          m_memory.clear();
-        }
-      }
-
-      void read_to_memory()
-      {
-        m_memory.clear();
-        uint64_t const fileSize = m_file.Size();
-        if (fileSize == 0) return;
-
-        LOG_SHORT(LINFO, ("Offsets reading is started for file ", get_name()));
-
-        try
-        {
-          m_memory.resize(uint64_to_size(fileSize / sizeof(element_t)));
-        }
-        catch (exception const &) // bad_alloc
-        {
-          LOG(LCRITICAL, ("Insufficient memory for required offset map"));
-        }
-
-        m_file.Read(0, &m_memory[0], uint64_to_size(fileSize));
-
-        sort(m_memory.begin(), m_memory.end(), element_less_t());
-
-        LOG_SHORT(LINFO, ("Offsets reading is finished"));
-      }
-
-      void write(uint64_t k, TValue const & v)
-      {
-        if (m_memory.size() > s_max_count)
-          flush_to_file();
-
-        m_memory.push_back(make_pair(k, v));
-      }
-
-      bool read_one(uint64_t k, TValue & v) const
-      {
-        typename id_cont_t::const_iterator i =
-            lower_bound(m_memory.begin(), m_memory.end(), k, element_less_t());
-        if ((i != m_memory.end()) && ((*i).first == k))
-        {
-          v = (*i).second;
-          return true;
-        }
-        return false;
-      }
-
-      typedef typename id_cont_t::const_iterator iter_t;
-      pair<iter_t, iter_t> GetRange(uint64_t k) const
-      {
-        return equal_range(m_memory.begin(), m_memory.end(), k, element_less_t());
-      }
-
-      template <class ToDo> void for_each_ret(uint64_t k, ToDo & toDo) const
-      {
-        pair<iter_t, iter_t> range = GetRange(k);
-        for (; range.first != range.second; ++range.first)
-          if (toDo((*range.first).second))
-            return;
-      }
-    };
-  }
+namespace detail
+{
+template <class TFile, class TValue>
+class IndexFile
+{
+  using TElement = pair<uint64_t, TValue>;
+  using TContainer = vector<TElement>;
 
-  template <class TStream, class TOffsetFile> class DataFileBase
-  {
-  public:
-    typedef uint64_t user_id_t;
+  TContainer m_elements;
+  TFile m_file;
 
-  protected:
-    TStream m_stream;
-    detail::file_map_t<TOffsetFile, uint64_t> m_offsets;
+  static size_t constexpr kFlushCount = 1024;
 
-  public:
-    DataFileBase(string const & name)
-      : m_stream(name), m_offsets(name + OFFSET_EXT)
+  struct ElementComparator
+  {
+    bool operator()(TElement const & r1, TElement const & r2) const
     {
+      return ((r1.first == r2.first) ? r1.second < r2.second : r1.first < r2.first);
     }
+    bool operator()(TElement const & r1, uint64_t r2) const { return (r1.first < r2); }
+    bool operator()(uint64_t r1, TElement const & r2) const { return (r1 < r2.first); }
   };
 
-  class DataFileWriter : public DataFileBase<FileWriterStream, FileWriter>
+  size_t CheckedCast(uint64_t v)
+  {
+    ASSERT(v < numeric_limits<size_t>::max(), ("Value to long for memory address : ", v));
+    return static_cast<size_t>(v);
+  }
+
+public:
+  IndexFile(string const & name) : m_file(name.c_str()) {}
+
+  string GetFileName() const { return m_file.GetName(); }
+
+  void Flush()
   {
-    typedef DataFileBase<FileWriterStream, FileWriter> base_type;
+    if (m_elements.empty())
+      return;
 
-    static const size_t s_max_count = 1024;
+    m_file.Write(&m_elements[0], m_elements.size() * sizeof(TElement));
+    m_elements.clear();
+  }
+
+  void ReadAll()
+  {
+    m_elements.clear();
+    uint64_t const fileSize = m_file.Size();
+    if (fileSize == 0)
+      return;
 
-  public:
-    DataFileWriter(string const & name) : base_type(name) {}
+    LOG_SHORT(LINFO, ("Offsets reading is started for file ", GetFileName()));
 
-    template <class T> void Write(user_id_t id, T const & t)
+    try
     {
-      m_offsets.write(id, m_stream.Pos());
-      m_stream << t;
+      m_elements.resize(CheckedCast(fileSize / sizeof(TElement)));
     }
-
-    void SaveOffsets()
+    catch (exception const &)  // bad_alloc
     {
-      m_offsets.flush_to_file();
+      LOG(LCRITICAL, ("Insufficient memory for required offset map"));
     }
-  };
 
-  class DataFileReader : public DataFileBase<FileReaderStream, FileReader>
+    m_file.Read(0, &m_elements[0], CheckedCast(fileSize));
+
+    sort(m_elements.begin(), m_elements.end(), ElementComparator());
+
+    LOG_SHORT(LINFO, ("Offsets reading is finished"));
+  }
+
+  void Write(uint64_t k, TValue const & v)
   {
-    typedef DataFileBase<FileReaderStream, FileReader> base_type;
+    if (m_elements.size() > kFlushCount)
+      Flush();
 
-  public:
-    DataFileReader(string const & name) : base_type(name) {}
+    m_elements.push_back(make_pair(k, v));
+  }
 
-    template <class T> bool Read(user_id_t id, T & t)
+  bool GetValueByKey(uint64_t k, TValue & v) const
+  {
+    auto it = lower_bound(m_elements.begin(), m_elements.end(), k, ElementComparator());
+    if ((it != m_elements.end()) && ((*it).first == k))
     {
-      uint64_t pos;
-      if (m_offsets.read_one(id, pos))
-      {
-        m_stream.Seek(pos);
-        m_stream >> t;
-        return true;
-      }
-      else
-      {
-        LOG_SHORT(LWARNING, ("Can't find offset in file ", m_offsets.get_name(), " by id ", id) );
-        return false;
-      }
+      v = (*it).second;
+      return true;
     }
+    return false;
+  }
 
-    void LoadOffsets()
-    {
-      m_offsets.read_to_memory();
-    }
-  };
+  template <class ToDo>
+  void ForEachByKey(uint64_t k, ToDo & toDo) const
+  {
+    auto range = equal_range(m_elements.begin(), m_elements.end(), k, ElementComparator());
+    for (; range.first != range.second; ++range.first)
+      if (toDo((*range.first).second))
+        return;
+  }
+};
+} // namespace detail
+
+template <class TStream, class TOffsetFile>
+class DataFileBase
+{
+public:
+  typedef uint64_t TKey;
+
+protected:
+  TStream m_stream;
+  detail::IndexFile<TOffsetFile, uint64_t> m_offsets;
 
+public:
+  DataFileBase(string const & name) : m_stream(name), m_offsets(name + OFFSET_EXT) {}
+};
 
-  template <class TNodesHolder, class TData, class TFile>
-  class BaseFileHolder
+class DataFileWriter : public DataFileBase<FileWriterStream, FileWriter>
+{
+  typedef DataFileBase<FileWriterStream, FileWriter> base_type;
+
+public:
+  DataFileWriter(string const & name) : base_type(name) {}
+
+  template <class T>
+  void Write(TKey id, T const & t)
   {
-  protected:
-    typedef typename TData::user_id_t user_id_t;
+    m_offsets.Write(id, m_stream.Pos());
+    m_stream << t;
+  }
 
-    TNodesHolder & m_nodes;
+  void SaveOffsets() { m_offsets.Flush(); }
+};
 
-    TData m_ways, m_relations;
+class DataFileReader : public DataFileBase<FileReaderStream, FileReader>
+{
+  typedef DataFileBase<FileReaderStream, FileReader> base_type;
 
-    typedef detail::file_map_t<TFile, uint64_t> offset_map_t;
-    offset_map_t m_nodes2rel, m_ways2rel;
+public:
+  DataFileReader(string const & name) : base_type(name) {}
 
-  public:
-    BaseFileHolder(TNodesHolder & nodes, string const & dir)
-      : m_nodes(nodes),
-        m_ways(dir + WAYS_FILE),
-        m_relations(dir + RELATIONS_FILE),
-        m_nodes2rel(dir + NODES_FILE + ID2REL_EXT),
-        m_ways2rel(dir + WAYS_FILE + ID2REL_EXT)
+  template <class T>
+  bool Read(TKey id, T & t)
+  {
+    uint64_t pos;
+    if (m_offsets.GetValueByKey(id, pos))
     {
+      m_stream.Seek(pos);
+      m_stream >> t;
+      return true;
     }
-  };
+    else
+    {
+      LOG_SHORT(LWARNING, ("Can't find offset in file ", m_offsets.GetFileName(), " by id ", id));
+      return false;
+    }
+  }
+
+  void LoadOffsets() { m_offsets.ReadAll(); }
+};
+
+template <class TNodesHolder, class TData, class TFile>
+class BaseFileHolder
+{
+protected:
+  using TKey = typename TData::TKey;
+  using TIndex = detail::IndexFile<TFile, uint64_t>;
+
+  TNodesHolder & m_nodes;
+
+  TData m_ways;
+  TData m_relations;
+
+  TIndex m_nodes2rel;
+  TIndex m_ways2rel;
+
+public:
+  BaseFileHolder(TNodesHolder & nodes, string const & dir)
+    : m_nodes(nodes)
+    , m_ways(dir + WAYS_FILE)
+    , m_relations(dir + RELATIONS_FILE)
+    , m_nodes2rel(dir + NODES_FILE + ID2REL_EXT)
+    , m_ways2rel(dir + WAYS_FILE + ID2REL_EXT)
+  {
+  }
+};
 }
diff --git a/generator/osm_source.cpp b/generator/osm_source.cpp
index 3c77b4ddf0..2be357d0a7 100644
--- a/generator/osm_source.cpp
+++ b/generator/osm_source.cpp
@@ -28,80 +28,72 @@ namespace feature
   template <class TNodesHolder>
   class FileHolder : public cache::BaseFileHolder<TNodesHolder, cache::DataFileReader, FileReader>
   {
-    typedef cache::DataFileReader reader_t;
-    typedef cache::BaseFileHolder<TNodesHolder, reader_t, FileReader> base_type;
+    using TReader = cache::DataFileReader;
+    using TBase = cache::BaseFileHolder<TNodesHolder, TReader, FileReader>;
 
-    typedef typename base_type::offset_map_t offset_map_t;
+    using typename TBase::TKey;
 
-    typedef typename base_type::user_id_t user_id_t;
-
-    template <class TElement, class ToDo> struct process_base
+    template <class TElement, class ToDo>
+    struct ElementProcessorBase
     {
     protected:
-      reader_t & m_reader;
+      TReader & m_reader;
       ToDo & m_toDo;
+
     public:
-      process_base(reader_t & reader, ToDo & toDo) : m_reader(reader), m_toDo(toDo) {}
+      ElementProcessorBase(TReader & reader, ToDo & toDo) : m_reader(reader), m_toDo(toDo) {}
 
-      bool operator() (uint64_t id)
+      bool operator()(uint64_t id)
       {
         TElement e;
-        if (m_reader.Read(id, e))
-          return m_toDo(id, e);
-        return false;
+        return m_reader.Read(id, e) ? m_toDo(id, e) : false;
       }
     };
 
-    template <class ToDo> struct process_relation : public process_base<RelationElement, ToDo>
+    template <class ToDo>
+    struct RelationProcessor : public ElementProcessorBase<RelationElement, ToDo>
     {
-      typedef process_base<RelationElement, ToDo> base_type;
-    public:
-      process_relation(reader_t & reader, ToDo & toDo) : base_type(reader, toDo) {}
+      using TBase = ElementProcessorBase<RelationElement, ToDo>;
+      RelationProcessor(TReader & reader, ToDo & toDo) : TBase(reader, toDo) {}
     };
 
-    template <class ToDo> struct process_relation_cached : public process_relation<ToDo>
+    template <class ToDo>
+    struct CachedRelationProcessor : public RelationProcessor<ToDo>
     {
-      typedef process_relation<ToDo> base_type;
-
-    public:
-      process_relation_cached(reader_t & rels, ToDo & toDo)
-      : base_type(rels, toDo) {}
-
-      bool operator() (uint64_t id)
-      {
-        return this->m_toDo(id, this->m_reader);
-      }
+      using TBase = RelationProcessor<ToDo>;
+      CachedRelationProcessor(TReader & rels, ToDo & toDo) : TBase(rels, toDo) {}
+      bool operator()(uint64_t id) { return this->m_toDo(id, this->m_reader); }
     };
 
   public:
-    FileHolder(TNodesHolder & holder, string const & dir) : base_type(holder, dir) {}
+    FileHolder(TNodesHolder & holder, string const & dir) : TBase(holder, dir) {}
 
     bool GetNode(uint64_t id, double & lat, double & lng)
     {
       return this->m_nodes.GetPoint(id, lat, lng);
     }
 
-    bool GetWay(user_id_t id, WayElement & e)
+    bool GetWay(TKey id, WayElement & e)
     {
       return this->m_ways.Read(id, e);
     }
 
-    template <class ToDo> void ForEachRelationByWay(user_id_t id, ToDo & toDo)
+    template <class ToDo> void ForEachRelationByWay(TKey id, ToDo & toDo)
     {
-      process_relation<ToDo> processor(this->m_relations, toDo);
-      this->m_ways2rel.for_each_ret(id, processor);
+      RelationProcessor<ToDo> processor(this->m_relations, toDo);
+      this->m_ways2rel.ForEachByKey(id, processor);
     }
 
-    template <class ToDo> void ForEachRelationByNodeCached(user_id_t id, ToDo & toDo)
+    template <class ToDo> void ForEachRelationByNodeCached(TKey id, ToDo & toDo)
     {
-      process_relation_cached<ToDo> processor(this->m_relations, toDo);
-      this->m_nodes2rel.for_each_ret(id, processor);
+      CachedRelationProcessor<ToDo> processor(this->m_relations, toDo);
+      this->m_nodes2rel.ForEachByKey(id, processor);
     }
 
-    template <class ToDo> void ForEachRelationByWayCached(user_id_t id, ToDo & toDo)
+    template <class ToDo> void ForEachRelationByWayCached(TKey id, ToDo & toDo)
     {
-      process_relation_cached<ToDo> processor(this->m_relations, toDo);
-      this->m_ways2rel.for_each_ret(id, processor);
+      CachedRelationProcessor<ToDo> processor(this->m_relations, toDo);
+      this->m_ways2rel.ForEachByKey(id, processor);
     }
     
     void LoadIndex()
@@ -109,8 +101,8 @@ namespace feature
       this->m_ways.LoadOffsets();
       this->m_relations.LoadOffsets();
       
-      this->m_nodes2rel.read_to_memory();
-      this->m_ways2rel.read_to_memory();
+      this->m_nodes2rel.ReadAll();
+      this->m_ways2rel.ReadAll();
     }
   };
 } // namespace feature
@@ -123,13 +115,13 @@ namespace data
   {
     typedef cache::BaseFileHolder<TNodesHolder, cache::DataFileWriter, FileWriter> base_type;
 
-    typedef typename base_type::user_id_t user_id_t;
+    typedef typename base_type::TKey user_id_t;
 
     template <class TMap, class TVec>
     void add_id2rel_vector(TMap & rMap, user_id_t relid, TVec const & v)
     {
       for (size_t i = 0; i < v.size(); ++i)
-        rMap.write(v[i].first, relid);
+        rMap.Write(v[i].first, relid);
     }
 
   public:
@@ -162,8 +154,8 @@ namespace data
       this->m_ways.SaveOffsets();
       this->m_relations.SaveOffsets();
       
-      this->m_nodes2rel.flush_to_file();
-      this->m_ways2rel.flush_to_file();
+      this->m_nodes2rel.Flush();
+      this->m_ways2rel.Flush();
     }
   };
 } // namespace data