Review fixes.

base/base_tests/stl_helpers_test.cpp

@@ -125,4 +125,28 @@ UNIT_TEST(SortUnique_VectorTest)
   TestSortUnique<vector>();
   TestSortUnique<deque>();
 }
+
+UNIT_TEST(IgnoreFirstArgument)
+{
+  {
+    int s = 0;
+    auto f1 = [&](int a, int b) { s += a + b; };
+    auto f2 = [&](int a, int b) { s -= a + b; };
+    auto f3 = my::MakeIgnoreFirstArgument(f2);
+
+    f1(2, 3);
+    TEST_EQUAL(s, 5, ());
+    f3(1, 2, 3);
+    TEST_EQUAL(s, 0, ());
+  }
+
+  {
+    auto f1 = [](int a, int b) -> int { return a + b; };
+    auto f2 = my::MakeIgnoreFirstArgument(f1);
+
+    auto const x = f1(2, 3);
+    auto const y = f2("ignored", 2, 3);
+    TEST_EQUAL(x, y, ());
+  }
+}
 }  // namespace

base/mem_trie.hpp

@@ -59,16 +59,6 @@ public:
       ForEachInNode(*root, prefix, std::forward<ToDo>(toDo));
   }
 
-  // Calls |toDo| for each value in the node that is reachable
-  // by |prefix| from the trie root. Does nothing if such node does
-  // not exist.
-  template <typename ToDo>
-  void ForEachValueInNode(String const & prefix, ToDo && toDo) const
-  {
-    if (auto const * root = MoveTo(prefix))
-      ForEachValueInNode(*root, std::forward<ToDo>(toDo));
-  }
-
   // Calls |toDo| for each key-value pair in a subtree that is
   // reachable by |prefix| from the trie root. Does nothing if such
   // subtree does not exist.
@@ -136,14 +126,6 @@ private:
       toDo(prefix, value);
   }
 
-  // Calls |toDo| for each value in |node|.
-  template <typename ToDo>
-  void ForEachValueInNode(Node const & node, ToDo && toDo) const
-  {
-    for (auto const & value : node.m_values)
-      toDo(value);
-  }
-
   // Calls |toDo| for each key-value pair in subtree where |node| is a
   // root of the subtree. |prefix| is a path from the trie root to the
   // |node|.

base/stl_helpers.hpp

@@ -2,6 +2,7 @@
 
 #include <algorithm>
 #include <functional>
+#include <type_traits>
 #include <utility>
 #include <vector>
 
@@ -137,4 +138,29 @@ typename std::underlying_type<T>::type Key(T value)
 {
   return static_cast<typename std::underlying_type<T>::type>(value);
 }
+
+// Use this if you want to make a functor whose first
+// argument is ignored and the rest are forwarded to |fn|.
+template <typename Fn>
+class IgnoreFirstArgument
+{
+public:
+  template <typename Gn>
+  IgnoreFirstArgument(Gn && gn) : m_fn(std::forward<Gn>(gn)) {}
+
+  template <typename Arg, typename... Args>
+  typename std::result_of<Fn(Args &&...)>::type operator()(Arg && arg, Args &&... args)
+  {
+    return m_fn(std::forward<Args>(args)...);
+  }
+
+private:
+  Fn m_fn;
+};
+
+template <typename Fn>
+IgnoreFirstArgument<Fn> MakeIgnoreFirstArgument(Fn && fn)
+{
+  return IgnoreFirstArgument<Fn>(std::forward<Fn>(fn));
+}
 }  // namespace my

indexer/categories_holder.cpp

@@ -201,7 +201,7 @@ void CategoriesHolder::AddCategory(Category & cat, vector<uint32_t> & types)
     for (auto const & synonym : p->m_synonyms)
     {
       auto const locale = synonym.m_locale;
-      ASSERT(locale != kUnsupportedLocaleCode, ());
+      ASSERT_NOT_EQUAL(locale, kUnsupportedLocaleCode, ());
 
       auto const uniName = search::NormalizeAndSimplifyString(synonym.m_name);
 
@@ -214,11 +214,8 @@ void CategoriesHolder::AddCategory(Category & cat, vector<uint32_t> & types)
           continue;
         for (uint32_t const t : types)
         {
-          if (m_name2type.find(locale) == m_name2type.end())
-            m_name2type[locale] = make_unique<Trie>();
-
-          auto * trie = m_name2type[locale].get();
-          trie->Add(token, t);
+          auto it = m_name2type.emplace(locale, make_unique<Trie>()).first;
+          it->second->Add(token, t);
         }
       }
     }

indexer/categories_holder.hpp

@@ -1,5 +1,7 @@
 #pragma once
+
 #include "base/mem_trie.hpp"
+#include "base/stl_helpers.hpp"
 #include "base/string_utils.hpp"
 
 #include "std/deque.hpp"
@@ -52,7 +54,10 @@ private:
   using Trie = my::MemTrie<String, uint32_t>;
 
   Type2CategoryCont m_type2cat;
+
+  // Maps locale and category token to the list of corresponding types.
   map<int8_t, unique_ptr<Trie>> m_name2type;
+
   GroupTranslations m_groupTranslations;
 
 public:
@@ -70,7 +75,7 @@ public:
   template <class ToDo>
   void ForEachCategory(ToDo && toDo) const
   {
-    for (auto & p : m_type2cat)
+    for (auto const & p : m_type2cat)
       toDo(*p.second);
   }
 
@@ -84,10 +89,9 @@ public:
   template <class ToDo>
   void ForEachName(ToDo && toDo) const
   {
-    for (auto & p : m_type2cat)
+    for (auto const & p : m_type2cat)
     {
-      shared_ptr<Category> cat = p.second;
-      for (auto const & synonym : cat->m_synonyms)
+      for (auto const & synonym : p.second->m_synonyms)
         toDo(synonym);
     }
   }
@@ -108,7 +112,7 @@ public:
     auto const it = m_name2type.find(locale);
     if (it == m_name2type.end())
       return;
-    it->second->ForEachValueInNode(name, forward<ToDo>(toDo));
+    it->second->ForEachInNode(name, my::MakeIgnoreFirstArgument(forward<ToDo>(toDo)));
   }
 
   inline GroupTranslations const & GetGroupTranslations() const { return m_groupTranslations; }