[generator] move translations to separate file

generator/CMakeLists.txt

@@ -212,6 +212,8 @@ set(
   tesselator.hpp
   towns_dumper.cpp
   towns_dumper.hpp
+  translation.hpp
+  translation.cpp
   traffic_generator.cpp
   traffic_generator.hpp
   transit_generator.cpp

generator/regions/region_base.cpp

@@ -1,59 +1,20 @@
 #include "generator/regions/region_base.hpp"
 
-#include "coding/transliteration.hpp"
-
 #include "base/assert.hpp"
 #include "base/control_flow.hpp"
-#include "base/string_utils.hpp"
 
 namespace generator
 {
 namespace regions
 {
-namespace
+std::string RegionWithName::GetName(LanguageCode languageCode) const
 {
-// Languages in order for better transliterations. This is kind
-// of workaround before real made translations.
-const std::unordered_map<RegionWithName::LanguageCode, RegionWithName::PreferredLanguages>
-    kPreferredLanguagesForTransliterate = {
-        {StringUtf8Multilang::GetLangIndex("ru"), {"en" /*English*/, "ru" /*Русский*/}},
-        {StringUtf8Multilang::GetLangIndex("en"), {"en" /*English*/, "ru" /*Русский*/}}};
-
-}  // namespace
-
-std::string RegionWithName::GetName(int8_t lang) const
-{
-  std::string s;
-  VERIFY(m_name.GetString(lang, s) != s.empty(), ());
-  return s;
+  return ::generator::GetName(m_name, languageCode);
 }
 
-std::string RegionWithName::GetTranslatedOrTransliteratedName(
-    RegionWithName::LanguageCode languageCode) const
+std::string RegionWithName::GetTranslatedOrTransliteratedName(LanguageCode languageCode) const
 {
-  std::string s = GetName(languageCode);
-  if (!s.empty() && strings::IsASCIIString(s))
-    return s;
-
-  s = GetName(StringUtf8Multilang::kInternationalCode);
-  if (!s.empty() && strings::IsASCIIString(s))
-    return s;
-
-  auto const fn = [&s](int8_t code, std::string const & name) {
-    if (code != StringUtf8Multilang::kDefaultCode &&
-        Transliteration::Instance().Transliterate(name, code, s) && strings::IsASCIIString(s))
-    {
-      return base::ControlFlow::Break;
-    }
-
-    return base::ControlFlow::Continue;
-  };
-
-  if (kPreferredLanguagesForTransliterate.count(languageCode) &&
-      !m_name.ForEachLanguage(kPreferredLanguagesForTransliterate.at(languageCode), fn))
-    m_name.ForEach(fn);
-
-  return s;
+  return ::generator::GetTranslatedOrTransliteratedName(m_name, languageCode);
 }
 
 StringUtf8Multilang const & RegionWithName::GetMultilangName() const { return m_name; }

generator/regions/region_base.hpp

@@ -2,6 +2,7 @@
 
 #include "generator/feature_builder.hpp"
 #include "generator/regions/region_info.hpp"
+#include "generator/translation.hpp"
 
 #include "geometry/rect2d.hpp"
 
@@ -27,9 +28,6 @@ using BoostRect = boost::geometry::model::box<BoostPoint>;
 class RegionWithName
 {
 public:
-  using LanguageCode = int8_t;
-  using PreferredLanguages = std::vector<std::string>;
-
   RegionWithName(StringUtf8Multilang const & name) : m_name(name) {}
 
   /// This function will take the following steps:

generator/translation.cpp

@@ -0,0 +1,48 @@
+#include "translation.hpp"
+
+#include "base/string_utils.hpp"
+#include "coding/transliteration.hpp"
+
+namespace
+{
+// Languages in order for better transliterations. This is kind
+// of workaround before real made translations.
+using PreferredLanguages = std::vector<std::string>;
+
+const std::unordered_map<generator::LanguageCode, PreferredLanguages>
+    kPreferredLanguagesForTransliterate = {
+        {StringUtf8Multilang::GetLangIndex("ru"), {"en" /*English*/, "ru" /*Русский*/}},
+        {StringUtf8Multilang::GetLangIndex("en"), {"en" /*English*/, "ru" /*Русский*/}}};
+}  // namespace
+
+namespace generator
+{
+std::string GetTranslatedOrTransliteratedName(StringUtf8Multilang const & name,
+                                              LanguageCode languageCode)
+{
+  std::string s = GetName(name, languageCode);
+  if (!s.empty() && strings::IsASCIIString(s))
+    return s;
+
+  s = GetName(name, StringUtf8Multilang::kInternationalCode);
+  if (!s.empty() && strings::IsASCIIString(s))
+    return s;
+
+  auto const fn = [&s](int8_t code, std::string const & name) {
+    if (code != StringUtf8Multilang::kDefaultCode &&
+        Transliteration::Instance().Transliterate(name, code, s) && strings::IsASCIIString(s))
+    {
+      return base::ControlFlow::Break;
+    }
+
+    return base::ControlFlow::Continue;
+  };
+
+  if (kPreferredLanguagesForTransliterate.count(languageCode) &&
+      !name.ForEachLanguage(kPreferredLanguagesForTransliterate.at(languageCode), fn))
+    name.ForEach(fn);
+
+  return s;
+}
+
+}  // namespace generator

generator/translation.hpp

@@ -0,0 +1,19 @@
+#pragma once
+
+#include "coding/string_utf8_multilang.hpp"
+
+namespace generator
+{
+using LanguageCode = int8_t;
+
+inline std::string GetName(StringUtf8Multilang const & name, int8_t lang)
+{
+  std::string s;
+  VERIFY(name.GetString(lang, s) != s.empty(), ());
+  return s;
+}
+
+std::string GetTranslatedOrTransliteratedName(StringUtf8Multilang const & name,
+                                              LanguageCode languageCode);
+
+}  // namespace generator