Disabled unity build for build checks

It was needed for KitKat devices

.github/workflows/linux-check.yaml

@@ -27,6 +27,11 @@ jobs:
         CMAKE_BUILD_TYPE: [Debug, RelWithDebInfo]
 
     steps:
+      - name: Free disk space by removing .NET, Android and Haskell
+        shell: bash
+        run: |
+          sudo rm -rf /usr/share/dotnet /usr/local/lib/android /opt/ghc
+
       - name: Checkout sources
         uses: actions/checkout@v2
 

3party/bsdiff-courgette/divsufsort/README.chromium

@@ -32,3 +32,4 @@ List of changes made to original code:
   - Added namespace divsuf.
   - Added divsufsort_with_empty().
   - Added unit tests.
+  - Patch to avoid int/uint comparison warnings.

3party/bsdiff-courgette/divsufsort/divsufsort.cc

@@ -57,8 +57,8 @@ sort_typeBstar(const sauchar_t *T, saidx_it SA,
   saint_t c0, c1;
 
   /* Initialize bucket arrays. */
-  for(i = 0; i < BUCKET_A_SIZE; ++i) { bucket_A[i] = 0; }
-  for(i = 0; i < BUCKET_B_SIZE; ++i) { bucket_B[i] = 0; }
+  for(i = 0; i < static_cast<saidx_t>(BUCKET_A_SIZE); ++i) { bucket_A[i] = 0; }
+  for(i = 0; i < static_cast<saidx_t>(BUCKET_B_SIZE); ++i) { bucket_B[i] = 0; }
 
   /* Count the number of occurrences of the first one or two characters of each
      type A, B and B* suffix. Moreover, store the beginning position of all
@@ -84,11 +84,11 @@ note:
 */
 
   /* Calculate the index of start/end point of each bucket. */
-  for(c0 = 0, i = 0, j = 0; c0 < ALPHABET_SIZE; ++c0) {
+  for(c0 = 0, i = 0, j = 0; c0 < static_cast<saint_t>(ALPHABET_SIZE); ++c0) {
     t = i + BUCKET_A(c0);
     BUCKET_A(c0) = i + j; /* start point */
     i = t + BUCKET_B(c0, c0);
-    for(c1 = c0 + 1; c1 < ALPHABET_SIZE; ++c1) {
+    for(c1 = c0 + 1; c1 < static_cast<saint_t>(ALPHABET_SIZE); ++c1) {
       j += BUCKET_BSTAR(c0, c1);
       BUCKET_BSTAR(c0, c1) = j; /* end point */
       i += BUCKET_B(c0, c1);
@@ -178,10 +178,9 @@ construct_SA(const sauchar_t *T, saidx_it SA,
        the sorted order of type B* suffixes. */
     for(c1 = ALPHABET_SIZE - 2; 0 <= c1; --c1) {
       /* Scan the suffix array from right to left. */
-      for(i = SA + BUCKET_BSTAR(c1, c1 + 1),
-          j = SA + BUCKET_A(c1 + 1) - 1, k = NULL, c2 = -1;
-          i <= j;
-          --j) {
+      for (i = SA + BUCKET_BSTAR(c1, c1 + 1), j = SA + BUCKET_A(c1 + 1) - 1,
+          k = nullptr, c2 = -1;
+           i <= j; --j) {
         if(0 < (s = *j)) {
           assert(T[s] == c1);
           assert(((s + 1) < n) && (T[s] <= T[s + 1]));
@@ -239,16 +238,24 @@ divsufsort(const sauchar_t *T, saidx_it SA, saidx_t n) {
   saint_t err = 0;
 
   /* Check arguments. */
-  if((T == NULL) || (SA == NULL) || (n < 0)) { return -1; }
-  else if(n == 0) { return 0; }
-  else if(n == 1) { SA[0] = 0; return 0; }
-  else if(n == 2) { m = (T[0] < T[1]); SA[m ^ 1] = 0, SA[m] = 1; return 0; }
+  if ((T == nullptr) || (SA == nullptr) || (n < 0)) {
+    return -1;
+  } else if (n == 0) {
+    return 0;
+  } else if (n == 1) {
+    SA[0] = 0;
+    return 0;
+  } else if (n == 2) {
+    m = (T[0] < T[1]);
+    SA[m ^ 1] = 0, SA[m] = 1;
+    return 0;
+  }
 
   bucket_A = (saidx_t *)malloc(BUCKET_A_SIZE * sizeof(saidx_t));
   bucket_B = (saidx_t *)malloc(BUCKET_B_SIZE * sizeof(saidx_t));
 
   /* Suffixsort. */
-  if((bucket_A != NULL) && (bucket_B != NULL)) {
+  if ((bucket_A != nullptr) && (bucket_B != nullptr)) {
     m = sort_typeBstar(T, SA, bucket_A, bucket_B, n);
     construct_SA(T, SA, bucket_A, bucket_B, n, m);
   } else {

3party/bsdiff-courgette/divsufsort/trsort.cc

@@ -51,7 +51,7 @@ namespace {
 
 /*- Private Functions -*/
 
-const saint_t lg_table[256]= {
+const saint_t lg_table_[256]= {
  -1,0,1,1,2,2,2,2,3,3,3,3,3,3,3,3,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,
   5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,
   6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,
@@ -67,11 +67,11 @@ saint_t
 tr_ilg(saidx_t n) {
   return (n & 0xffff0000) ?
           ((n & 0xff000000) ?
-            24 + lg_table[(n >> 24) & 0xff] :
-            16 + lg_table[(n >> 16) & 0xff]) :
+            24 + lg_table_[(n >> 24) & 0xff] :
+            16 + lg_table_[(n >> 16) & 0xff]) :
           ((n & 0x0000ff00) ?
-             8 + lg_table[(n >>  8) & 0xff] :
-             0 + lg_table[(n >>  0) & 0xff]);
+             8 + lg_table_[(n >>  8) & 0xff] :
+             0 + lg_table_[(n >>  0) & 0xff]);
 }
 
 
@@ -352,7 +352,7 @@ tr_introsort(saidx_it ISA, const_saidx_it ISAd,
 
         /* push */
         if(1 < (b - a)) {
-          STACK_PUSH5(NULL, a, b, 0, 0);
+          STACK_PUSH5(nullptr, a, b, 0, 0);
           STACK_PUSH5(ISAd - incr, first, last, -2, trlink);
           trlink = ssize - 2;
         }

3party/freetype/freetype

@@ -1 +1 @@
-Subproject commit d6a5c57727643fc7a0d30e10776edf9c2c5956ae
+Subproject commit 4eb6cb8818057a022f97176b53738ee3098c8eb6

3party/icu/CMakeLists.txt

@@ -1,7 +1,5 @@
 project(icu)
 
-# set(CMAKE_PREFIX_PATH ./)
-
 set(SRC
   uconfig_local.h
   icu/icu4c/source/common/appendable.cpp
@@ -131,3 +129,5 @@ target_include_directories(${PROJECT_NAME}
     icu/icu4c/source/common
     icu/icu4c/source/i18n
 )
+
+set_target_properties(${PROJECT_NAME} PROPERTIES UNITY_BUILD OFF)

CMakeLists.txt

@@ -8,6 +8,10 @@ set(CMAKE_C_STANDARD 11)
 set(CMAKE_CXX_EXTENSIONS OFF)
 set(CMAKE_C_EXTENSIONS OFF)
 
+#set(CMAKE_UNITY_BUILD ON)
+#set(CMAKE_UNITY_BUILD_BATCH_SIZE 50)
+
+
 if(NOT (DEFINED ENV{COLORS_DISABLE}) AND CMAKE_CXX_COMPILER_ID MATCHES "GNU|Clang")
   message(STATUS "export COLORS_DISABLE=1 to disable colored compiler output.")
   add_compile_options($<$<CXX_COMPILER_ID:GNU>:-fdiagnostics-color=always> $<$<CXX_COMPILER_ID:Clang,AppleClang>:-fcolor-diagnostics>)

android/build.gradle

@@ -159,7 +159,6 @@ android {
   ndkVersion '23.1.7779620'
 
   defaultConfig {
-    vectorDrawables.useSupportLibrary = true
     // Default package name is taken from the manifest and should be app.organicmaps
     def ver = getVersion()
     println('Version: ' + ver.first)

android/jni/com/mapswithme/maps/Framework.cpp

@@ -79,13 +79,10 @@ using platform::ToNativeNetworkPolicy;
 
 static_assert(sizeof(int) >= 4, "Size of jint in less than 4 bytes.");
 
+::Framework * frm() { return g_framework->NativeFramework(); }
+
 namespace
 {
-::Framework * frm()
-{
-  return g_framework->NativeFramework();
-}
-
 jobject g_placePageActivationListener = nullptr;
 
 android::AndroidVulkanContextFactory * CastFactory(drape_ptr<dp::GraphicsContextFactory> const & f)

android/jni/com/mapswithme/maps/Framework.hpp

@@ -199,3 +199,4 @@ namespace android
 }
 
 extern std::unique_ptr<android::Framework> g_framework;
+::Framework * frm();

android/jni/com/mapswithme/maps/LocationHelper.cpp

@@ -1,6 +1,5 @@
 #include "Framework.hpp"
 #include "map/gps_tracker.hpp"
-#include "platform/file_logging.hpp"
 
 extern "C"
 {
@@ -37,7 +36,6 @@ extern "C"
     if (speed > 0.0)
       info.m_speedMpS = speed;
 
-    LOG_MEMORY_INFO();
     if (g_framework)
       g_framework->OnLocationUpdated(info);
     GpsTracker::Instance().OnLocationUpdated(info);

android/jni/com/mapswithme/maps/MapFragment.cpp

@@ -8,7 +8,6 @@
 
 #include "base/logging.hpp"
 
-#include "platform/file_logging.hpp"
 #include "platform/settings.hpp"
 
 namespace

android/jni/com/mapswithme/maps/MapManager.cpp

@@ -51,9 +51,9 @@ struct TBatchedData
   {}
 };
 
-jmethodID g_listAddMethod;
-jclass g_countryItemClass;
-jobject g_countryChangedListener;
+jmethodID g_listAddMethod = nullptr;
+jclass g_countryItemClass = nullptr;
+jobject g_countryChangedListener = nullptr;
 
 DECLARE_THREAD_CHECKER(g_batchingThreadChecker);
 std::unordered_map<jobject, std::vector<TBatchedData>> g_batchedCallbackData;
@@ -61,11 +61,11 @@ bool g_isBatched;
 
 Storage & GetStorage()
 {
-  CHECK(g_framework != nullptr, ());
+  ASSERT(g_framework != nullptr, ());
   return g_framework->GetStorage();
 }
 
-void PrepareClassRefs(JNIEnv * env)
+void CacheListClassRefs(JNIEnv * env)
 {
   if (g_listAddMethod)
     return;
@@ -268,7 +268,7 @@ static void PutItemsToList(
 JNIEXPORT void JNICALL
 Java_com_mapswithme_maps_downloader_MapManager_nativeListItems(JNIEnv * env, jclass clazz, jstring parent, jdouble lat, jdouble lon, jboolean hasLocation, jboolean myMapsMode, jobject result)
 {
-  PrepareClassRefs(env);
+  CacheListClassRefs(env);
 
   if (hasLocation && !myMapsMode)
   {
@@ -291,9 +291,9 @@ Java_com_mapswithme_maps_downloader_MapManager_nativeListItems(JNIEnv * env, jcl
 
 // static void nativeUpdateItem(CountryItem item);
 JNIEXPORT void JNICALL
-Java_com_mapswithme_maps_downloader_MapManager_nativeGetAttributes(JNIEnv * env, jclass clazz, jobject item)
+Java_com_mapswithme_maps_downloader_MapManager_nativeGetAttributes(JNIEnv * env, jclass, jobject item)
 {
-  PrepareClassRefs(env);
+  CacheListClassRefs(env);
 
   static jfieldID countryItemFieldId = env->GetFieldID(g_countryItemClass, "id", "Ljava/lang/String;");
   jstring id = static_cast<jstring>(env->GetObjectField(item, countryItemFieldId));
@@ -462,7 +462,7 @@ static void ProgressChangedCallback(std::shared_ptr<jobject> const & listenerRef
 JNIEXPORT jint JNICALL
 Java_com_mapswithme_maps_downloader_MapManager_nativeSubscribe(JNIEnv * env, jclass clazz, jobject listener)
 {
-  PrepareClassRefs(env);
+  CacheListClassRefs(env);
   return GetStorage().Subscribe(std::bind(&StatusChangedCallback, jni::make_global_ref(listener), _1),
                                 std::bind(&ProgressChangedCallback, jni::make_global_ref(listener), _1, _2));
 }

android/jni/com/mapswithme/maps/TrackRecorder.cpp

@@ -4,16 +4,6 @@
 
 #include <chrono>
 
-namespace
-{
-
-::Framework * frm()
-{
-  return (g_framework ? g_framework->NativeFramework() : nullptr);
-}
-
-}  // namespace
-
 extern "C"
 {
   JNIEXPORT void JNICALL

android/jni/com/mapswithme/maps/bookmarks/data/BookmarkManager.cpp

@@ -21,8 +21,6 @@ using namespace std::placeholders;
 
 namespace
 {
-::Framework * frm() { return g_framework->NativeFramework(); }
-
 jclass g_bookmarkManagerClass;
 jfieldID g_bookmarkManagerInstanceField;
 jmethodID g_onBookmarksChangedMethod;

android/jni/com/mapswithme/maps/sound/tts.cpp

@@ -2,12 +2,6 @@
 
 #include "com/mapswithme/core/jni_helper.hpp"
 
-
-namespace
-{
-  ::Framework * frm() { return g_framework->NativeFramework(); }
-} //  namespace
-
 extern "C"
 {
   JNIEXPORT void JNICALL

android/jni/com/mapswithme/util/Config.cpp

@@ -2,11 +2,6 @@
 #include "com/mapswithme/maps/Framework.hpp"
 #include "platform/settings.hpp"
 
-namespace
-{
-::Framework * frm() { return g_framework->NativeFramework(); }
-}
-
 extern "C"
 {
   JNIEXPORT jboolean JNICALL

base/base_tests/math_test.cpp

@@ -51,8 +51,8 @@ UNIT_TEST(AlmostEqualULPs_double)
   TEST_ALMOST_EQUAL_ULPS(3.0, 3.0, ());
   TEST_ALMOST_EQUAL_ULPS(+0.0, -0.0, ());
 
-  double const eps = std::numeric_limits<double>::epsilon();
-  double const dmax = std::numeric_limits<double>::max();
+  double constexpr eps = std::numeric_limits<double>::epsilon();
+  double constexpr dmax = std::numeric_limits<double>::max();
 
   TEST_ALMOST_EQUAL_ULPS(1.0 + eps, 1.0, ());
   TEST_ALMOST_EQUAL_ULPS(1.0 - eps, 1.0, ());
@@ -96,8 +96,8 @@ UNIT_TEST(AlmostEqualULPs_float)
 
 UNIT_TEST(AlmostEqual_Smoke)
 {
-  double const small = 1e-18;
-  double const eps = 1e-10;
+  double constexpr small = 1e-18;
+  double constexpr eps = 1e-10;
 
   TEST(base::AlmostEqualAbs(0.0, 0.0 + small, eps), ());
   TEST(!base::AlmostEqualRel(0.0, 0.0 + small, eps), ());

base/base_tests/newtype_test.cpp

@@ -6,7 +6,7 @@
 #include <string>
 #include <type_traits>
 
-namespace
+namespace newtype_test
 {
 NEWTYPE(int, Int);
 
@@ -112,4 +112,4 @@ UNIT_TEST(NewType_SimpleOutPut)
   sstr << Int(20);
   TEST_EQUAL(sstr.str(), "20", ());
 }
-}  // namespace
+}  // namespace newtype_test

base/base_tests/stl_helpers_tests.cpp

@@ -10,7 +10,7 @@
 
 using namespace base;
 
-namespace
+namespace stl_helpers_test
 {
 class Int
 {
@@ -153,7 +153,7 @@ UNIT_TEST(IgnoreFirstArgument)
   }
 }
 
-namespace 
+namespace
 {
   struct EqualZero
   {
@@ -326,4 +326,4 @@ UNIT_TEST(AccumulateIntervals)
     CheckAccumulateIntervals(idTest, arr1, arr2, res);
   }
 }
-}  // namespace
+}  // namespace stl_helpers_test

base/base_tests/thread_safe_queue_tests.cpp

@@ -13,7 +13,7 @@ using namespace base::thread_pool::delayed;
 
 UNIT_TEST(ThreadSafeQueue_ThreadSafeQueue)
 {
-  base::threads::ThreadSafeQueue<size_t> queue;
+  threads::ThreadSafeQueue<size_t> queue;
 
   TEST(queue.Empty(), ());
   TEST_EQUAL(queue.Size(), 0, ());
@@ -22,7 +22,7 @@ UNIT_TEST(ThreadSafeQueue_ThreadSafeQueue)
 UNIT_TEST(ThreadSafeQueue_Push)
 {
   size_t const kSize = 100;
-  base::threads::ThreadSafeQueue<size_t> queue;
+  threads::ThreadSafeQueue<size_t> queue;
   ThreadPool pool(2, ThreadPool::Exit::ExecPending);
   for (size_t i = 0; i < kSize; ++i)
   {
@@ -39,7 +39,7 @@ UNIT_TEST(ThreadSafeQueue_Push)
 UNIT_TEST(ThreadSafeQueue_WaitAndPop)
 {
   using namespace std::chrono_literals;
-  base::threads::ThreadSafeQueue<size_t> queue;
+  threads::ThreadSafeQueue<size_t> queue;
   size_t const value = 101;
   size_t result;
   auto thread = std::thread([&]() {
@@ -57,7 +57,7 @@ UNIT_TEST(ThreadSafeQueue_WaitAndPop)
 UNIT_TEST(ThreadSafeQueue_TryPop)
 {
   using namespace std::chrono_literals;
-  base::threads::ThreadSafeQueue<size_t> queue;
+  threads::ThreadSafeQueue<size_t> queue;
   size_t const value = 101;
   size_t result;
   auto thread = std::thread([&]() {
@@ -75,7 +75,7 @@ UNIT_TEST(ThreadSafeQueue_TryPop)
 UNIT_TEST(ThreadSafeQueue_ExampleWithDataWrapper)
 {
   size_t const kSize = 100000;
-  base::threads::ThreadSafeQueue<std::optional<size_t>> queue;
+  threads::ThreadSafeQueue<std::optional<size_t>> queue;
 
   auto thread = std::thread([&]() {
     while (true)

base/stl_iterator.hpp

@@ -2,25 +2,25 @@
 
 #include <boost/iterator/iterator_facade.hpp>
 
-namespace detail
+namespace stl_iterator_detail
 {
 struct Dummy
 {
   template <class T> Dummy & operator=(T const &) { return *this; }
 };
-}
+}  // namespace stl_iterator_detail
 
 class CounterIterator :
-    public boost::iterator_facade<CounterIterator, detail::Dummy, boost::forward_traversal_tag>
+    public boost::iterator_facade<CounterIterator, stl_iterator_detail::Dummy, boost::forward_traversal_tag>
 {
   size_t m_count;
 public:
   CounterIterator() : m_count(0) {}
   size_t GetCount() const { return m_count; }
 
-  detail::Dummy & dereference() const
+  stl_iterator_detail::Dummy & dereference() const
   {
-    static detail::Dummy dummy;
+    static stl_iterator_detail::Dummy dummy;
     return dummy;
   }
   void increment() { ++m_count; }

base/thread_safe_queue.hpp

@@ -5,8 +5,6 @@
 #include <queue>
 #include <utility>
 
-namespace base
-{
 namespace threads
 {
 template <typename T>
@@ -76,4 +74,3 @@ private:
   std::condition_variable m_cond;
 };
 }  // namespace threads
-}  // namespace base

base/thread_utils.hpp

@@ -5,8 +5,6 @@
 
 #include "base/macros.hpp"
 
-namespace base
-{
 namespace threads
 {
 template <typename Thread = std::thread, typename ThreadContainer = std::vector<Thread>>
@@ -77,4 +75,3 @@ private:
   DISALLOW_COPY(FunctionWrapper);
 };
 }  // namespace threads
-}  // namespace base

cmake/OmimHelpers.cmake

@@ -71,6 +71,8 @@ endfunction()
 
 function(omim_add_library library)
   add_library(${library} ${ARGN})
+  # set_target_properties(${library} PROPERTIES UNITY_BUILD ON)
+  # set_target_properties(${library} PROPERTIES UNITY_BUILD_BATCH_SIZE 50)
   add_dependencies(${library} BuildVersion)
   # Enable warnings for all our libraries.
   target_compile_options(${library} PRIVATE ${OMIM_WARNING_FLAGS})

coding/coding_tests/url_tests.cpp

@@ -2,14 +2,17 @@
 
 #include "coding/url.hpp"
 
+#include "base/math.hpp"
+
 #include <queue>
 #include <string>
 #include <utility>
 
-using namespace std;
-
-namespace
+namespace url_tests
 {
+using namespace std;
+using namespace url;
+
 double const kEps = 1e-10;
 
 class TestUrl
@@ -27,7 +30,7 @@ public:
 
   ~TestUrl()
   {
-    url::Url url(m_url);
+    Url url(m_url);
     TEST_EQUAL(url.GetScheme(), m_scheme, ());
     TEST_EQUAL(url.GetPath(), m_path, ());
     TEST(!m_scheme.empty() || !url.IsValid(), ("Scheme is empty if and only if url is invalid!"));
@@ -35,7 +38,7 @@ public:
   }
 
 private:
-  void AddTestValue(url::Param const & param)
+  void AddTestValue(Param const & param)
   {
     TEST(!m_keyValuePairs.empty(), ("Failed for url = ", m_url, "Passed KV = ", param));
     TEST_EQUAL(m_keyValuePairs.front().first, param.m_name, ());
@@ -48,7 +51,6 @@ private:
   string m_path;
   queue<pair<string, string>> m_keyValuePairs;
 };
-}  // namespace
 
 namespace url_encode_testdata
 {
@@ -62,8 +64,6 @@ char const * orig4 = "#$%^&@~[]{}()|*+`\"\'";
 char const * enc4 = "%23%24%25%5E%26%40~%5B%5D%7B%7D%28%29%7C%2A%2B%60%22%27";
 }  // namespace url_encode_testdata
 
-namespace url
-{
 UNIT_TEST(Url_Join)
 {
   TEST_EQUAL("", Join("", ""), ());
@@ -251,4 +251,4 @@ UNIT_TEST(UrlComprehensive)
       .KV("key2", "").KV("key2", "")
       .KV("key3", "value1").KV("key3", "").KV("key3", "value2");
 }
-}  // namespace url
+}  // namespace url_tests

descriptions/CMakeLists.txt

@@ -10,6 +10,9 @@ set(SRC
 
 omim_add_library(${PROJECT_NAME} ${SRC})
 
-target_link_libraries(${PROJECT_NAME} coding)
+target_link_libraries(${PROJECT_NAME}
+  indexer  # MwmHandle
+  coding
+)
 
 omim_add_test_subdirectory(descriptions_tests)

drape/drape_tests/CMakeLists.txt

@@ -8,7 +8,6 @@ set(SRC
   buffer_tests.cpp
   dummy_texture.hpp
   font_texture_tests.cpp
-  gl_functions.cpp
   gl_mock_functions.cpp
   gl_mock_functions.hpp
   glyph_mng_tests.cpp

drape/drape_tests/uniform_value_tests.cpp

@@ -20,7 +20,7 @@ using ::testing::Invoke;
 using ::testing::InSequence;
 using namespace dp;
 
-namespace
+namespace uniform_value_tests
 {
 template<typename T>
 class MemoryComparer
@@ -74,7 +74,6 @@ void mock_glGetActiveUniform(uint32_t programID, uint32_t index, int32_t * size,
     ASSERT(false, ("Undefined index:", index));
   }
 }
-}  // namespace
 
 UNIT_TEST(UniformValueTest)
 {
@@ -179,3 +178,4 @@ UNIT_TEST(UniformValueTest)
   vs.reset();
   fs.reset();
 }
+}  // namespace uniform_value_tests

drape_frontend/apply_feature_functors.cpp

@@ -20,6 +20,7 @@
 #include "indexer/road_shields_parser.hpp"
 
 #include "geometry/clipping.hpp"
+#include "geometry/mercator.hpp"
 #include "geometry/smoothing.hpp"
 
 #include "drape/color.hpp"
@@ -657,10 +658,9 @@ void ApplyAreaFeature::ProcessBuildingPolygon(m2::PointD const & p1, m2::PointD
 
 int ApplyAreaFeature::GetIndex(m2::PointD const & pt)
 {
-  double constexpr kEps = 1e-7;
   for (size_t i = 0; i < m_points.size(); i++)
   {
-    if (pt.EqualDxDy(m_points[i], kEps))
+    if (pt.EqualDxDy(m_points[i], mercator::kPointEqualityEps))
       return static_cast<int>(i);
   }
   m_points.push_back(pt);

drape_frontend/arrow3d.cpp

@@ -14,10 +14,12 @@
 
 namespace df
 {
+namespace arrow3d {
 double constexpr kArrowSize = 12.0;
 double constexpr kArrow3dScaleMin = 1.0;
 double constexpr kArrow3dScaleMax = 2.2;
 int constexpr kArrow3dMinZoom = 16;
+}  // namespace arrow3d
 
 float constexpr kOutlineScale = 1.2f;
 
@@ -40,12 +42,12 @@ Arrow3d::Arrow3d(ref_ptr<dp::GraphicsContext> context)
     0.0f, 0.0f, -1.0f, 1.0f,    0.0f,  2.0f, 0.0f, 1.0f,    1.2f, -1.0f, 0.0f, 1.0f,
     0.0f, 0.0f, -1.0f, 1.0f,    0.0f, -0.5f, 0.0f, 1.0f,    -1.2f, -1.0f, 0.0f, 1.0f,
     0.0f, 0.0f, -1.0f, 1.0f,    1.2f, -1.0f, 0.0f, 1.0f,    0.0f, -0.5f, 0.0f, 1.0f,
-    
+
     0.0f, 2.27f, 0.0f, 0.0f,    1.4f, -1.17f, 0.0f, 0.0f,   0.0f, 2.0f, 0.0f, 1.0f,
     0.0f, 2.0f, 0.0f, 1.0f,     1.4f, -1.17f, 0.0f, 0.0f,   1.2f, -1.0f, 0.0f, 1.0f,
     0.0f, 2.27f, 0.0f, 0.0f,    0.0f, 2.0f, 0.0f, 1.0f,     -1.4f, -1.17f, 0.0f, 0.0f,
     0.0f, 2.0f, 0.0f, 1.0f,     -1.2f, -1.0f, 0.0f, 1.0f,   -1.4f, -1.17f, 0.0f, 0.0f,
-    
+
     1.2f, -1.0f, 0.0f, 1.0f,    1.4f, -1.17f, 0.0f, 0.0f,   0.0f, -0.67f, 0.0f, 0.0f,
     0.0f, -0.5f, 0.0f, 1.0f,    1.2f, -1.0f, 0.0f, 1.0f,    0.0f, -0.67f, 0.0f, 0.0f,
     -1.2f, -1.0f, 0.0f, 1.0f,   0.0f, -0.67f, 0.0f, 0.0f,   -1.4f, -1.17f, 0.0f, 0.0f,
@@ -74,7 +76,7 @@ Arrow3d::Arrow3d(ref_ptr<dp::GraphicsContext> context)
 double Arrow3d::GetMaxBottomSize()
 {
   double const kBottomSize = 1.0;
-  return kBottomSize * kArrowSize * kArrow3dScaleMax * kOutlineScale;
+  return kBottomSize * arrow3d::kArrowSize * arrow3d::kArrow3dScaleMax * kOutlineScale;
 }
 
 void Arrow3d::SetPosition(const m2::PointD & position)
@@ -140,11 +142,11 @@ void Arrow3d::RenderArrow(ref_ptr<dp::GraphicsContext> context, ref_ptr<gpu::Pro
 math::Matrix<float, 4, 4> Arrow3d::CalculateTransform(ScreenBase const & screen, float dz,
                                                       float scaleFactor, dp::ApiVersion apiVersion) const
 {
-  double arrowScale = VisualParams::Instance().GetVisualScale() * kArrowSize * scaleFactor;
+  double arrowScale = VisualParams::Instance().GetVisualScale() * arrow3d::kArrowSize * scaleFactor;
   if (screen.isPerspective())
   {
-    double const t = GetNormalizedZoomLevel(screen.GetScale(), kArrow3dMinZoom);
-    arrowScale *= (kArrow3dScaleMin * (1.0 - t) + kArrow3dScaleMax * t);
+    double const t = GetNormalizedZoomLevel(screen.GetScale(), arrow3d::kArrow3dMinZoom);
+    arrowScale *= (arrow3d::kArrow3dScaleMin * (1.0 - t) + arrow3d::kArrow3dScaleMax * t);
   }
 
   auto const scaleX = static_cast<float>(arrowScale * 2.0 / screen.PixelRect().SizeX());

drape_frontend/frontend_renderer.cpp

@@ -2727,7 +2727,7 @@ m2::AnyRectD TapInfo::GetRoutingPointTapRect(m2::PointD const & mercator, Screen
 }
 
 // static
-m2::AnyRectD TapInfo::GetPreciseTapRect(m2::PointD const & mercator, double const eps)
+m2::AnyRectD TapInfo::GetPreciseTapRect(m2::PointD const & mercator, double eps)
 {
   return m2::AnyRectD(mercator, ang::AngleD(0.0) /* angle */, m2::RectD(-eps, -eps, eps, eps));
 }

drape_frontend/frontend_renderer.hpp

@@ -71,7 +71,7 @@ struct TapInfo
   static m2::AnyRectD GetBookmarkTapRect(m2::PointD const & mercator, ScreenBase const & screen);
   static m2::AnyRectD GetRoutingPointTapRect(m2::PointD const & mercator, ScreenBase const & screen);
   static m2::AnyRectD GetGuideTapRect(m2::PointD const & mercator, ScreenBase const & screen);
-  static m2::AnyRectD GetPreciseTapRect(m2::PointD const & mercator, double const eps);
+  static m2::AnyRectD GetPreciseTapRect(m2::PointD const & mercator, double eps);
 };
 
 class FrontendRenderer : public BaseRenderer,

drape_frontend/my_position.cpp

@@ -17,7 +17,7 @@
 
 namespace df
 {
-namespace
+namespace mp
 {
 df::ColorConstant const kMyPositionAccuracyColor = "MyPositionAccuracy";
 
@@ -52,7 +52,7 @@ dp::BindingInfo GetMarkerBindingInfo()
 
   return info;
 }
-}  // namespace
+}  // namespace mp
 
 MyPosition::MyPosition(ref_ptr<dp::GraphicsContext> context, ref_ptr<dp::TextureManager> mng)
   : m_position(m2::PointF::Zero())
@@ -159,10 +159,10 @@ void MyPosition::CacheAccuracySector(ref_ptr<dp::GraphicsContext> context,
   auto const etalonSector = static_cast<float>(2.0 * math::pi / kTriangleCount);
 
   dp::TextureManager::ColorRegion color;
-  mng->GetColorRegion(df::GetColorConstant(df::kMyPositionAccuracyColor), color);
+  mng->GetColorRegion(df::GetColorConstant(mp::kMyPositionAccuracyColor), color);
   glsl::vec2 colorCoord = glsl::ToVec2(color.GetTexRect().Center());
 
-  buffer_vector<MarkerVertex, kTriangleCount> buffer;
+  buffer_vector<mp::MarkerVertex, kTriangleCount> buffer;
   glsl::vec2 startNormal(0.0f, 1.0f);
 
   for (size_t i = 0; i < kTriangleCount + 1; ++i)
@@ -193,7 +193,7 @@ void MyPosition::CacheAccuracySector(ref_ptr<dp::GraphicsContext> context,
     });
 
     dp::AttributeProvider provider(1 /* stream count */, kVertexCount);
-    provider.InitStream(0 /* stream index */, GetMarkerBindingInfo(), make_ref(buffer.data()));
+    provider.InitStream(0 /* stream index */, mp::GetMarkerBindingInfo(), make_ref(buffer.data()));
 
     m_parts[MyPositionAccuracy].first = batcher.InsertTriangleList(context, state,
                                                                    make_ref(&provider), nullptr);
@@ -209,7 +209,7 @@ void MyPosition::CacheSymbol(ref_ptr<dp::GraphicsContext> context,
   m2::RectF const & texRect = symbol.GetTexRect();
   m2::PointF const halfSize = symbol.GetPixelSize() * 0.5f;
 
-  MarkerVertex data[4] =
+  mp::MarkerVertex data[4] =
   {
     { glsl::vec2(-halfSize.x,  halfSize.y), glsl::ToVec2(texRect.LeftTop()) },
     { glsl::vec2(-halfSize.x, -halfSize.y), glsl::ToVec2(texRect.LeftBottom()) },
@@ -218,7 +218,7 @@ void MyPosition::CacheSymbol(ref_ptr<dp::GraphicsContext> context,
   };
 
   dp::AttributeProvider provider(1 /* streamCount */, dp::Batcher::VertexPerQuad);
-  provider.InitStream(0 /* streamIndex */, GetMarkerBindingInfo(), make_ref(data));
+  provider.InitStream(0 /* streamIndex */, mp::GetMarkerBindingInfo(), make_ref(data));
   m_parts[part].first = batcher.InsertTriangleStrip(context, state, make_ref(&provider), nullptr);
   ASSERT(m_parts[part].first.IsValid(), ());
 }

drape_frontend/path_text_handle.cpp

@@ -10,9 +10,9 @@ namespace df
 
 namespace
 {
-double const kValidSplineTurn = 15 * math::pi / 180;
-double const kCosTurn = cos(kValidSplineTurn);
-double const kSinTurn = sin(kValidSplineTurn);
+double const kValidPathSplineTurn = 15 * math::pi / 180;
+double const kCosTurn = cos(kValidPathSplineTurn);
+double const kSinTurn = sin(kValidPathSplineTurn);
 double const kRoundStep = 23;
 int const kMaxStepsCount = 7;
 
@@ -91,7 +91,7 @@ void AddPointAndRound(m2::Spline & spline, m2::PointD const & pt)
   double const dotProduct = m2::DotProduct(dir1, dir2);
   if (dotProduct < kCosTurn)
   {
-    int leftStepsCount = static_cast<int>(acos(dotProduct) / kValidSplineTurn);
+    int leftStepsCount = static_cast<int>(acos(dotProduct) / kValidPathSplineTurn);
     std::vector<m2::PointD> roundedCorner;
     while (leftStepsCount > 0 && leftStepsCount <= kMaxStepsCount &&
            RoundCorner(spline.GetPath()[spline.GetSize() - 2],

drape_frontend/read_metaline_task.cpp

@@ -10,6 +10,8 @@
 #include "coding/reader_wrapper.hpp"
 #include "coding/varint.hpp"
 
+#include "geometry/mercator.hpp"
+
 #include "indexer/feature_decl.hpp"
 #include "indexer/scales.hpp"
 
@@ -22,8 +24,6 @@
 
 namespace
 {
-double const kPointEqualityEps = 1e-7;
-
 struct MetalineData
 {
   std::vector<FeatureID> m_features;
@@ -31,7 +31,7 @@ struct MetalineData
 };
 
 std::vector<MetalineData> ReadMetalinesFromFile(MwmSet::MwmId const & mwmId)
-{ 
+{
   try
   {
     std::vector<MetalineData> model;
@@ -81,7 +81,7 @@ std::map<FeatureID, std::vector<m2::PointD>> ReadPoints(df::MapDataProvider & mo
     featurePoints.reserve(5);
     ft.ForEachPoint([&featurePoints](m2::PointD const & pt)
     {
-      if (featurePoints.empty() || !featurePoints.back().EqualDxDy(pt, kPointEqualityEps))
+      if (featurePoints.empty() || !featurePoints.back().EqualDxDy(pt, mercator::kPointEqualityEps))
         featurePoints.push_back(pt);
     }, scales::GetUpperScale());
 
@@ -117,7 +117,7 @@ std::vector<m2::PointD> MergePoints(std::map<FeatureID, std::vector<m2::PointD>>
     ASSERT(it != points.cend(), ());
     for (auto const & pt : it->second)
     {
-      if (result.empty() || !result.back().EqualDxDy(pt, kPointEqualityEps))
+      if (result.empty() || !result.back().EqualDxDy(pt, mercator::kPointEqualityEps))
         result.push_back(pt);
     }
   }

drape_frontend/route_shape.cpp

@@ -45,7 +45,7 @@ std::array<float, 20> const kRouteHalfWidthInPixelOthers =
   1.5f, 1.7f, 2.3f, 2.7f, 3.5, 4.5f, 5.0f, 7.0f, 11.0f, 13.0f
 };
 
-namespace
+namespace rs
 {
 float const kLeftSide = 1.0f;
 float const kCenter = 0.0f;
@@ -166,7 +166,7 @@ glsl::vec3 MarkerNormal(float x, float y, float z, float cosAngle, float sinAngl
 {
   return glsl::vec3(x * cosAngle - y * sinAngle, x * sinAngle + y * cosAngle, z);
 }
-} // namespace
+} // namespace rs
 
 void Subroute::AddStyle(SubrouteStyle const & style)
 {
@@ -205,7 +205,7 @@ void RouteShape::PrepareGeometry(std::vector<m2::PointD> const & path, m2::Point
   double constexpr kMinExtent = mercator::Bounds::kRangeX / (1 << 10);
 
   float depth = baseDepth;
-  float const depthStep = kRouteDepth / (1 + segments.size());
+  float const depthStep = rs::kRouteDepth / (1 + segments.size());
   for (auto i = static_cast<int>(segments.size() - 1); i >= 0; i--)
   {
     auto & geomBufferData = geometryBufferData.back();
@@ -240,22 +240,22 @@ void RouteShape::PrepareGeometry(std::vector<m2::PointD> const & path, m2::Point
     float const projRightEnd = segments[i].m_rightWidthScalar[EndPoint].y;
 
     geometry.emplace_back(startPivot, glsl::vec2(0, 0),
-                          glsl::vec3(startLength, 0, kCenter), segments[i].m_color);
+                          glsl::vec3(startLength, 0, rs::kCenter), segments[i].m_color);
     geometry.emplace_back(startPivot, leftNormalStart,
-                          glsl::vec3(startLength, projLeftStart, kLeftSide), segments[i].m_color);
+                          glsl::vec3(startLength, projLeftStart, rs::kLeftSide), segments[i].m_color);
     geometry.emplace_back(endPivot, glsl::vec2(0, 0),
-                          glsl::vec3(length, 0, kCenter), segments[i].m_color);
+                          glsl::vec3(length, 0, rs::kCenter), segments[i].m_color);
     geometry.emplace_back(endPivot, leftNormalEnd,
-                          glsl::vec3(length, projLeftEnd, kLeftSide), segments[i].m_color);
+                          glsl::vec3(length, projLeftEnd, rs::kLeftSide), segments[i].m_color);
 
     geometry.emplace_back(startPivot, rightNormalStart,
-                          glsl::vec3(startLength, projRightStart, kRightSide), segments[i].m_color);
+                          glsl::vec3(startLength, projRightStart, rs::kRightSide), segments[i].m_color);
     geometry.emplace_back(startPivot, glsl::vec2(0, 0),
-                          glsl::vec3(startLength, 0, kCenter), segments[i].m_color);
+                          glsl::vec3(startLength, 0, rs::kCenter), segments[i].m_color);
     geometry.emplace_back(endPivot, rightNormalEnd,
-                          glsl::vec3(length, projRightEnd, kRightSide), segments[i].m_color);
+                          glsl::vec3(length, projRightEnd, rs::kRightSide), segments[i].m_color);
     geometry.emplace_back(endPivot, glsl::vec2(0, 0),
-                          glsl::vec3(length, 0, kCenter), segments[i].m_color);
+                          glsl::vec3(length, 0, rs::kCenter), segments[i].m_color);
 
     auto & joinsGeometry = geomBufferData.m_joinsGeometry;
 
@@ -275,8 +275,8 @@ void RouteShape::PrepareGeometry(std::vector<m2::PointD> const & path, m2::Point
       GenerateJoinNormals(dp::RoundJoin, n1, n2, 1.0f, segments[i].m_hasLeftJoin[EndPoint],
                           widthScalar, normals);
 
-      GenerateJoinsTriangles(endPivot, normals, segments[i].m_color, glsl::vec2(length, 0),
-                             segments[i].m_hasLeftJoin[EndPoint], joinsGeometry);
+      rs::GenerateJoinsTriangles(endPivot, normals, segments[i].m_color, glsl::vec2(length, 0),
+                                 segments[i].m_hasLeftJoin[EndPoint], joinsGeometry);
     }
 
     // Generate caps.
@@ -288,8 +288,8 @@ void RouteShape::PrepareGeometry(std::vector<m2::PointD> const & path, m2::Point
                          segments[i].m_rightNormals[StartPoint], -segments[i].m_tangent,
                          1.0f, true /* isStart */, normals);
 
-      GenerateJoinsTriangles(startPivot, normals, segments[i].m_color, glsl::vec2(startLength, 0),
-                             true, joinsGeometry);
+      rs::GenerateJoinsTriangles(startPivot, normals, segments[i].m_color, glsl::vec2(startLength, 0),
+                                 true, joinsGeometry);
     }
 
     if (i == static_cast<int>(segments.size()) - 1)
@@ -300,8 +300,8 @@ void RouteShape::PrepareGeometry(std::vector<m2::PointD> const & path, m2::Point
                          segments[i].m_rightNormals[EndPoint], segments[i].m_tangent,
                          1.0f, false /* isStart */, normals);
 
-      GenerateJoinsTriangles(endPivot, normals, segments[i].m_color, glsl::vec2(length, 0),
-                             true, joinsGeometry);
+      rs::GenerateJoinsTriangles(endPivot, normals, segments[i].m_color, glsl::vec2(length, 0),
+                                 true, joinsGeometry);
     }
 
     auto const verticesCount = geomBufferData.m_geometry.size() + geomBufferData.m_joinsGeometry.size();
@@ -355,9 +355,9 @@ void RouteShape::PrepareArrowGeometry(std::vector<m2::PointD> const & path, m2::
     glsl::vec2 const leftNormalEnd = GetNormal(segments[i], true /* isLeft */, EndNormal);
     glsl::vec2 const rightNormalEnd = GetNormal(segments[i], false /* isLeft */, EndNormal);
 
-    glsl::vec2 const uvCenter = GetUV(tr, 0.5f, 0.5f);
-    glsl::vec2 const uvLeft = GetUV(tr, 0.5f, 0.0f);
-    glsl::vec2 const uvRight = GetUV(tr, 0.5f, 1.0f);
+    glsl::vec2 const uvCenter = rs::GetUV(tr, 0.5f, 0.5f);
+    glsl::vec2 const uvLeft = rs::GetUV(tr, 0.5f, 0.0f);
+    glsl::vec2 const uvRight = rs::GetUV(tr, 0.5f, 1.0f);
 
     geometry.emplace_back(startPivot, glsl::vec2(0, 0), uvCenter);
     geometry.emplace_back(startPivot, leftNormalStart, uvLeft);
@@ -393,7 +393,7 @@ void RouteShape::PrepareArrowGeometry(std::vector<m2::PointD> const & path, m2::
 
       ASSERT_EQUAL(normals.size(), uv.size(), ());
 
-      GenerateArrowsTriangles(endPivot, normals, tr, uv, true /* normalizedUV */, joinsGeometry);
+      rs::GenerateArrowsTriangles(endPivot, normals, tr, uv, true /* normalizedUV */, joinsGeometry);
     }
 
     // Generate arrow head.
@@ -409,7 +409,7 @@ void RouteShape::PrepareArrowGeometry(std::vector<m2::PointD> const & path, m2::
       std::vector<glsl::vec2> uv = { glsl::vec2(u, 1.0f), glsl::vec2(u, 0.0f), glsl::vec2(1.0f, 0.5f) };
       glsl::vec4 const headPivot = glsl::vec4(glsl::ToVec2(endPt), depth, 1.0);
       depth += depthInc;
-      GenerateArrowsTriangles(headPivot, normals, texRect, uv, true /* normalizedUV */, joinsGeometry);
+      rs::GenerateArrowsTriangles(headPivot, normals, texRect, uv, true /* normalizedUV */, joinsGeometry);
     }
 
     // Generate arrow tail.
@@ -433,7 +433,7 @@ void RouteShape::PrepareArrowGeometry(std::vector<m2::PointD> const & path, m2::
         glsl::ToVec2(t.LeftTop())
       };
 
-      GenerateArrowsTriangles(startPivot, normals, texRect, uv, false /* normalizedUV */, joinsGeometry);
+      rs::GenerateArrowsTriangles(startPivot, normals, texRect, uv, false /* normalizedUV */, joinsGeometry);
     }
   }
 }
@@ -490,13 +490,13 @@ void RouteShape::PrepareMarkersGeometry(std::vector<SubrouteMarker> const & mark
       auto const sinAngle = static_cast<float>(m2::CrossProduct(marker.m_up, m2::PointD(0.0, 1.0)));
 
       // Here we use a right triangle to render half-circle.
-      geometry.emplace_back(outerPos, MarkerNormal(-kSqrt2, 0.0f, outerRadius, cosAngle, sinAngle), c1);
-      geometry.emplace_back(outerPos, MarkerNormal(0.0f, -kSqrt2, outerRadius, cosAngle, sinAngle), c1);
-      geometry.emplace_back(outerPos, MarkerNormal(0.0f, kSqrt2, outerRadius, cosAngle, sinAngle), c1);
+      geometry.emplace_back(outerPos, rs::MarkerNormal(-kSqrt2, 0.0f, outerRadius, cosAngle, sinAngle), c1);
+      geometry.emplace_back(outerPos, rs::MarkerNormal(0.0f, -kSqrt2, outerRadius, cosAngle, sinAngle), c1);
+      geometry.emplace_back(outerPos, rs::MarkerNormal(0.0f, kSqrt2, outerRadius, cosAngle, sinAngle), c1);
 
-      geometry.emplace_back(outerPos, MarkerNormal(kSqrt2, 0.0f, outerRadius, cosAngle, sinAngle), c2);
-      geometry.emplace_back(outerPos, MarkerNormal(0.0f, kSqrt2, outerRadius, cosAngle, sinAngle), c2);
-      geometry.emplace_back(outerPos, MarkerNormal(0.0f, -kSqrt2, outerRadius, cosAngle, sinAngle), c2);
+      geometry.emplace_back(outerPos, rs::MarkerNormal(kSqrt2, 0.0f, outerRadius, cosAngle, sinAngle), c2);
+      geometry.emplace_back(outerPos, rs::MarkerNormal(0.0f, kSqrt2, outerRadius, cosAngle, sinAngle), c2);
+      geometry.emplace_back(outerPos, rs::MarkerNormal(0.0f, -kSqrt2, outerRadius, cosAngle, sinAngle), c2);
     }
 
     if (marker.m_colors.size() > 1 || marker.m_colors.front() != marker.m_innerColor)
@@ -519,18 +519,18 @@ void RouteShape::CacheRouteArrows(ref_ptr<dp::GraphicsContext> context,
 {
   GeometryBufferData<ArrowGeometryBuffer> geometryData;
   dp::TextureManager::SymbolRegion region;
-  GetArrowTextureRegion(mng, region);
+  rs::GetArrowTextureRegion(mng, region);
   auto state = CreateRenderState(gpu::Program::RouteArrow, DepthLayer::GeometryLayer);
   state.SetColorTexture(region.GetTexture());
   state.SetTextureIndex(region.GetTextureIndex());
 
   // Generate arrow geometry.
-  auto depth = static_cast<float>(baseDepthIndex * kDepthPerSubroute) + kArrowsDepth;
-  float const depthStep = (kArrowsDepth - kRouteDepth) / (1 + borders.size());
+  auto depth = static_cast<float>(baseDepthIndex * rs::kDepthPerSubroute) + rs::kArrowsDepth;
+  float const depthStep = (rs::kArrowsDepth - rs::kRouteDepth) / (1 + borders.size());
   for (ArrowBorders const & b : borders)
   {
     depth -= depthStep;
-    std::vector<m2::PointD> points = CalculatePoints(polyline, b.m_startDistance, b.m_endDistance);
+    std::vector<m2::PointD> points = rs::CalculatePoints(polyline, b.m_startDistance, b.m_endDistance);
     ASSERT_LESS_OR_EQUAL(points.size(), polyline.GetSize(), ());
     PrepareArrowGeometry(points, routeArrowsData.m_pivot, region.GetTexRect(), depthStep,
                          depth, geometryData);
@@ -600,7 +600,7 @@ drape_ptr<df::SubrouteData> RouteShape::CacheRoute(ref_ptr<dp::GraphicsContext>
 
   std::vector<GeometryBufferData<GeometryBuffer>> geometryBufferData;
   PrepareGeometry(points, subrouteData->m_pivot, segmentsColors,
-                  static_cast<float>(subroute->m_baseDepthIndex * kDepthPerSubroute),
+                  static_cast<float>(subroute->m_baseDepthIndex * rs::kDepthPerSubroute),
                   geometryBufferData);
 
   auto state = CreateRenderState(subroute->m_style[styleIndex].m_pattern.m_isDashed ?
@@ -635,7 +635,7 @@ drape_ptr<df::SubrouteMarkersData> RouteShape::CacheMarkers(ref_ptr<dp::Graphics
   markersData->m_recacheId = recacheId;
 
   MarkersGeometryBuffer geometry;
-  auto const depth = static_cast<float>(subroute->m_baseDepthIndex * kDepthPerSubroute + kMarkersDepth);
+  auto const depth = static_cast<float>(subroute->m_baseDepthIndex * rs::kDepthPerSubroute + rs::kMarkersDepth);
   PrepareMarkersGeometry(subroute->m_markers, markersData->m_pivot, depth, geometry);
   if (geometry.empty())
     return nullptr;

drape_frontend/selection_shape_generator.cpp

@@ -13,6 +13,8 @@
 #include "indexer/feature.hpp"
 #include "indexer/scales.hpp"
 
+#include "geometry/mercator.hpp"
+
 #include "base/buffer_vector.hpp"
 #include "base/macros.hpp"
 #include "base/math.hpp"
@@ -26,7 +28,6 @@ namespace
 {
 std::string const kTrackSelectedSymbolName = "track_marker_selected";
 df::ColorConstant const kSelectionColor = "Selection";
-double const kPointEqualityEps = 1e-7;
 float const kLeftSide = 1.0f;
 float const kCenter = 0.0f;
 float const kRightSide = -1.0f;
@@ -232,7 +233,7 @@ drape_ptr<RenderNode> SelectionShapeGenerator::GenerateSelectionGeometry(ref_ptr
       points.reserve(5);
       ft.ForEachPoint([&points](m2::PointD const & pt)
       {
-       if (points.empty() || !points.back().EqualDxDy(pt, kPointEqualityEps))
+       if (points.empty() || !points.back().EqualDxDy(pt, mercator::kPointEqualityEps))
          points.push_back(pt);
       }, scales::GetUpperScale());
     }, std::vector<FeatureID>{feature});

editor/feature_matcher.cpp

@@ -1,6 +1,7 @@
 #include "editor/feature_matcher.hpp"
 
 #include "geometry/intersection_score.hpp"
+#include "geometry/mercator.hpp"
 
 #include "base/logging.hpp"
 #include "base/stl_helpers.hpp"
@@ -302,7 +303,7 @@ double ScoreTriangulatedGeometriesByPoints(vector<m2::PointD> const & lhs,
                                         CounterIterator(),
                                         [](m2::PointD const & p1, m2::PointD const & p2)
                                         {
-                                          return p1 < p2 && !p1.EqualDxDy(p2, 1e-7);
+                                          return p1 < p2 && !p1.EqualDxDy(p2, mercator::kPointEqualityEps);
                                         }).GetCount();
 
   return static_cast<double>(matched) / lhs.size();

generator/CMakeLists.txt

@@ -253,6 +253,14 @@ target_link_libraries(${PROJECT_NAME}
   $<$<BOOL:CMAKE_DL_LIBS>:${CMAKE_DL_LIBS}>  # dladdr from boost::stacktrace
 )
 
+# Disable unity build to avoid boost::geometry macro errors.
+set_source_files_properties(
+  affiliation.cpp
+  final_processor_country.cpp
+  hierarchy.cpp
+  PROPERTIES SKIP_UNITY_BUILD_INCLUSION TRUE
+)
+
 omim_add_test_subdirectory(generator_tests_support)
 omim_add_test_subdirectory(generator_tests)
 omim_add_test_subdirectory(generator_integration_tests)

generator/affiliation.cpp

@@ -19,10 +19,10 @@
 BOOST_GEOMETRY_REGISTER_POINT_2D(m2::PointD, double, boost::geometry::cs::cartesian, x, y);
 BOOST_GEOMETRY_REGISTER_RING(std::vector<m2::PointD>);
 
-namespace
+namespace feature
+{
+namespace affiliation
 {
-using namespace feature;
-
 template <typename T>
 struct RemoveCvref
 {
@@ -70,7 +70,7 @@ void ForEachPoint(T && t, F && f)
 
 // An implementation for CountriesFilesAffiliation class.
 template <typename T>
-std::vector<std::string> GetAffiliations(T && t,
+std::vector<std::string> GetAffiliations(T const & t,
                                          borders::CountryPolygonsCollection const & countryPolygonsTree,
                                          bool haveBordersForWholeWorld)
 {
@@ -168,10 +168,8 @@ std::vector<std::string> GetAffiliations(T && t, IndexSharedPtr const & index)
   auto const oneCountry = IsOneCountryForLimitRect(GetLimitRect(t), index);
   return oneCountry ? std::vector<std::string>{*oneCountry} : GetHonestAffiliations(t, index);
 }
-}  // namespace
+}  // namespace affiliation
 
-namespace feature
-{
 CountriesFilesAffiliation::CountriesFilesAffiliation(std::string const & borderPath, bool haveBordersForWholeWorld)
   : m_countryPolygonsTree(borders::GetOrCreateCountryPolygonsTree(borderPath))
   , m_haveBordersForWholeWorld(haveBordersForWholeWorld)
@@ -180,13 +178,13 @@ CountriesFilesAffiliation::CountriesFilesAffiliation(std::string const & borderP
 
 std::vector<std::string> CountriesFilesAffiliation::GetAffiliations(FeatureBuilder const & fb) const
 {
-  return ::GetAffiliations(fb, m_countryPolygonsTree, m_haveBordersForWholeWorld);
+  return affiliation::GetAffiliations(fb, m_countryPolygonsTree, m_haveBordersForWholeWorld);
 }
 
 std::vector<std::string>
 CountriesFilesAffiliation::GetAffiliations(m2::PointD const & point) const
 {
-  return ::GetAffiliations(point, m_countryPolygonsTree, m_haveBordersForWholeWorld);
+  return affiliation::GetAffiliations(point, m_countryPolygonsTree, m_haveBordersForWholeWorld);
 }
 
 bool CountriesFilesAffiliation::HasCountryByName(std::string const & name) const
@@ -221,12 +219,12 @@ CountriesFilesIndexAffiliation::CountriesFilesIndexAffiliation(std::string const
 
 std::vector<std::string> CountriesFilesIndexAffiliation::GetAffiliations(FeatureBuilder const & fb) const
 {
-  return ::GetAffiliations(fb, m_index);
+  return affiliation::GetAffiliations(fb, m_index);
 }
 
 std::vector<std::string> CountriesFilesIndexAffiliation::GetAffiliations(m2::PointD const & point) const
 {
-  return ::GetAffiliations(point, m_index);
+  return affiliation::GetAffiliations(point, m_index);
 }
 
 std::shared_ptr<CountriesFilesIndexAffiliation::Tree>
@@ -254,7 +252,7 @@ CountriesFilesIndexAffiliation::BuildIndex(const std::vector<m2::RectD> & net)
         }
         else
         {
-          auto const box = MakeBox(rect);
+          auto const box = affiliation::MakeBox(rect);
           std::vector<std::reference_wrapper<borders::CountryPolygons const>> interCountries;
           for (borders::CountryPolygons const & cp : countries)
           {
@@ -293,7 +291,7 @@ CountriesFilesIndexAffiliation::BuildIndex(const std::vector<m2::RectD> & net)
         {
           std::vector<std::reference_wrapper<borders::CountryPolygons const>> interCountries{*countryPtr};
           std::lock_guard<std::mutex> lock(treeCellsMutex);
-          treeCells.emplace_back(MakeBox(rect), std::move(interCountries));
+          treeCells.emplace_back(affiliation::MakeBox(rect), std::move(interCountries));
         }
       });
     }

generator/city_roads_generator.cpp

@@ -9,7 +9,7 @@
 #include "platform/platform.hpp"
 
 #include "indexer/feature.hpp"
-#include "indexer/feature_data.cpp"
+#include "indexer/feature_data.hpp"
 #include "indexer/feature_processor.hpp"
 
 #include "coding/read_write_utils.hpp"
@@ -18,10 +18,12 @@
 #include "base/geo_object_id.hpp"
 #include "base/logging.hpp"
 
-#include <utility>
-
 #include "defines.hpp"
 
+#include <utility>
+
+namespace routing
+{
 using namespace generator;
 using namespace std;
 
@@ -62,9 +64,9 @@ vector<uint32_t> CalcRoadFeatureIds(string const & dataPath, string const & boun
   CitiesBoundariesChecker const checker(citiesBoundaries);
 
   vector<uint32_t> cityRoadFeatureIds;
-  ForEachFeature(dataPath, [&cityRoadFeatureIds, &checker](FeatureType & ft, uint32_t)
+  feature::ForEachFeature(dataPath, [&cityRoadFeatureIds, &checker](FeatureType & ft, uint32_t)
   {
-    TypesHolder types(ft);
+    feature::TypesHolder types(ft);
     if (!routing::IsCarRoad(types) && !routing::IsBicycleRoad(types))
       return;
 
@@ -91,8 +93,6 @@ vector<uint32_t> CalcRoadFeatureIds(string const & dataPath, string const & boun
 }
 }  // namespace
 
-namespace routing
-{
 void SerializeCityRoads(string const & dataPath, vector<uint32_t> && cityRoadFeatureIds)
 {
   if (cityRoadFeatureIds.empty())

generator/collector_routing_city_boundaries.cpp

@@ -60,7 +60,7 @@ bool IsSuitablePlaceType(ftypes::LocalityType localityType)
   }
 }
 
-ftypes::LocalityType GetPlaceType(FeatureBuilder const & feature)
+ftypes::LocalityType GetPlaceLocalityType(FeatureBuilder const & feature)
 {
   return ftypes::IsLocalityChecker::Instance().GetType(feature.GetTypesHolder());
 }
@@ -156,7 +156,7 @@ RoutingCityBoundariesCollector::RoutingCityBoundariesCollector(
 std::shared_ptr<CollectorInterface> RoutingCityBoundariesCollector::Clone(
     std::shared_ptr<cache::IntermediateDataReaderInterface> const & cache) const
 {
-  return std::make_shared<RoutingCityBoundariesCollector>(GetFilename(), m_dumpFilename, 
+  return std::make_shared<RoutingCityBoundariesCollector>(GetFilename(), m_dumpFilename,
                                                           cache ? cache : m_cache);
 }
 
@@ -181,7 +181,7 @@ void RoutingCityBoundariesCollector::Process(feature::FeatureBuilder & feature,
 {
   ASSERT(FilterOsmElement(osmElement), ());
 
-  if (feature.IsArea() && IsSuitablePlaceType(::GetPlaceType(feature)))
+  if (feature.IsArea() && IsSuitablePlaceType(GetPlaceLocalityType(feature)))
   {
     if (feature.PreSerialize())
       m_writer->Process(feature);
@@ -208,7 +208,7 @@ void RoutingCityBoundariesCollector::Process(feature::FeatureBuilder & feature,
   }
   else if (feature.IsPoint())
   {
-    auto const placeType = ::GetPlaceType(feature);
+    auto const placeType = GetPlaceLocalityType(feature);
 
     // Elements which have multiple place tags i.e. "place=country" + "place=city" will pass FilterOsmElement()
     // but can have bad placeType here. As we do not know what's the real place type let's skip such places.

generator/features_processing_helpers.hpp

@@ -25,5 +25,5 @@ struct ProcessedData
 };
 
 using FeatureProcessorChunk = std::optional<std::vector<ProcessedData>>;
-using FeatureProcessorQueue = base::threads::ThreadSafeQueue<FeatureProcessorChunk>;
+using FeatureProcessorQueue = threads::ThreadSafeQueue<FeatureProcessorChunk>;
 }  // namespace generator

generator/final_processor_country.cpp

@@ -29,11 +29,11 @@
 BOOST_GEOMETRY_REGISTER_POINT_2D(m2::PointD, double, boost::geometry::cs::cartesian, x, y)
 BOOST_GEOMETRY_REGISTER_RING(std::vector<m2::PointD>)
 
+namespace generator
+{
 using namespace base::thread_pool::computational;
 using namespace feature;
 
-namespace generator
-{
 CountryFinalProcessor::CountryFinalProcessor(std::string const & borderPath,
                                              std::string const & temporaryMwmPath,
                                              std::string const & intermediateDir,

generator/generator_integration_tests/features_tests.cpp

@@ -430,11 +430,6 @@ private:
     classificator::Load();
     auto & platform = GetPlatform();
 
-    // Should be initialized in testingmain.cpp
-    //auto const & options = GetTestingOptions();
-    //platform.SetResourceDir(options.m_resourcePath);
-    //platform.SetSettingsDir(options.m_resourcePath);
-
     m_threadCount = static_cast<size_t>(platform.CpuCores());
     m_testPath = base::JoinPath(platform.WritableDir(), "gen-test");
     m_genInfo.SetNodeStorageType("map");

generator/generator_tests/altitude_test.cpp

@@ -31,14 +31,14 @@
 #include <string>
 #include <vector>
 
+namespace altitude_test
+{
 using namespace feature;
 using namespace generator;
 using namespace platform;
 using namespace platform::tests_support;
 using namespace routing;
 
-namespace
-{
 // These tests generate mwms with altitude sections and then check if altitudes
 // in the mwms are correct. The mwms are initialized with different sets of features.
 // There are several restrictions for these features:
@@ -254,4 +254,4 @@ UNIT_TEST(AltitudeGenerationTest_FourRoadsWithoutAltitude)
   std::vector<TPoint3DList> const roads = {kRoad1, kRoad2, kRoad3, kRoad4};
   TestBuildingNoFeatureHasAltitude(roads, false /* hasAltitudeExpected */);
 }
-}  // namespace
+}  // namespace altitude_test

generator/generator_tests/city_roads_tests.cpp

@@ -32,14 +32,14 @@
 
 #include "defines.hpp"
 
+namespace city_roads_tests
+{
 using namespace coding;
 using namespace platform::tests_support;
 using namespace platform;
 using namespace routing;
 using namespace std;
 
-namespace
-{
 // Directory name for creating test mwm and temporary files.
 string const kTestDir = "city_roads_generation_test";
 // Temporary mwm name for testing.
@@ -173,4 +173,4 @@ UNIT_TEST(CityRoadsGenerationTest_UnsortedIds3)
        182452, 303265, 73616, 262562, 62935, 294606, 466803, 215791, 468825, 76934, 18187,
        194429, 32913}));
 }
-}  // namespace
+}  // namespace city_roads_tests

generator/generator_tests/collector_boundary_postcode_tests.cpp

@@ -20,13 +20,13 @@
 #include <utility>
 #include <vector>
 
+namespace collector_boundary_postcode_tests
+{
 using namespace generator_tests;
 using namespace generator;
 using namespace feature;
 using namespace std;
 
-namespace
-{
 using BoundariesCollector = RoutingCityBoundariesCollector;
 
 string const kDumpFileName = "dump.bin";
@@ -132,7 +132,7 @@ bool CheckPostcodeExists(unordered_map<string, vector<m2::PointD>> const & data,
 
   for (size_t i = 0; i < geometry.size(); ++i)
   {
-    if (!base::AlmostEqualAbs(geometry[i], it->second[i], kMwmPointAccuracy))
+    if (!m2::AlmostEqualAbs(geometry[i], it->second[i], kMwmPointAccuracy))
       return false;
   }
 
@@ -160,7 +160,7 @@ void Check(string const & dumpFilename)
   TEST(CheckPostcodeExists(data, "127003", ConvertIdsToPoints(kPolygon3)), (data));
   TEST(CheckPostcodeExists(data, "127004", ConvertIdsToPoints(kPolygon4)), (data));
 }
-}  // namespace
+
 
 UNIT_TEST(CollectorBoundaryPostcode_1)
 {
@@ -200,3 +200,4 @@ UNIT_TEST(CollectorBoundaryPostcode_2)
 
   Check(kDumpFileName);
 }
+}  // namespace collector_boundary_postcode_tests

generator/generator_tests/collector_building_parts_tests.cpp

@@ -17,7 +17,7 @@
 #include <memory>
 #include <unordered_map>
 
-namespace
+namespace collector_building_parts_tests
 {
 using namespace generator::tests_support;
 
@@ -241,4 +241,4 @@ UNIT_CLASS_TEST(TestWithClassificator, CollectorBuildingParts_Case2)
   TestCollector(file.GetFullPath(), fb2, *intermediateReader,
                 IntermediateDataReaderTest::kTopRelationId2);
 }
-}  // namespace
+}  // namespace collector_building_parts_tests

generator/generator_tests/collector_city_area_tests.cpp

@@ -20,10 +20,10 @@
 #include <memory>
 #include <vector>
 
+namespace collector_city_area_tests
+{
 using namespace generator_tests;
 
-namespace
-{
 feature::FeatureBuilder MakeFbForTest(OsmElement element)
 {
   feature::FeatureBuilder result;
@@ -45,7 +45,6 @@ auto const o1 = MakeOsmElement(1 /* id */, {{"place", "city"}} /* tags */, OsmEl
 auto const o2 = MakeOsmElement(2 /* id */, {{"place", "town"}} /* tags */, OsmElement::EntityType::Relation);
 auto const o3 = MakeOsmElement(3 /* id */, {{"place", "village"}} /* tags */, OsmElement::EntityType::Relation);
 auto const o4 = MakeOsmElement(4 /* id */, {{"place", "country"}} /* tags */, OsmElement::EntityType::Relation);
-}  // namespace
 
 UNIT_TEST(CollectorCityArea_Merge)
 {
@@ -70,3 +69,4 @@ UNIT_TEST(CollectorCityArea_Merge)
   TEST(HasRelationWithId(fbs, 2 /* id */), ());
   TEST(HasRelationWithId(fbs, 3 /* id */), ());
 }
+}  // namespace collector_city_area_tests

generator/generator_tests/collector_routing_city_boundaries_tests.cpp

@@ -22,13 +22,13 @@
 #include <memory>
 #include <vector>
 
+namespace collector_routing_city_boundaries_tests
+{
 using namespace generator_tests;
 using namespace generator;
-using namespace tests_support;
+using namespace generator::tests_support;
 using namespace feature;
 
-namespace
-{
 using BoundariesCollector = RoutingCityBoundariesCollector;
 
 std::string const kDumpFileName = "dump.bin";
@@ -131,7 +131,7 @@ bool CheckPolygonExistance(std::vector<std::vector<m2::PointD>> const & polygons
 
     for (size_t i = 0; i < polygon.size(); ++i)
     {
-      if (!base::AlmostEqualAbs(polygon[i], polygonToFind[i], 1e-6))
+      if (!m2::AlmostEqualAbs(polygon[i], polygonToFind[i], 1e-6))
       {
         same = false;
         break;
@@ -202,7 +202,7 @@ double CalculateEarthAreaForConvexPolygon(std::vector<ms::LatLon> const & latlon
 
   return area;
 }
-}  // namespace
+
 
 UNIT_CLASS_TEST(TestWithClassificator, CollectorRoutingCityBoundaries_1)
 {
@@ -210,7 +210,7 @@ UNIT_CLASS_TEST(TestWithClassificator, CollectorRoutingCityBoundaries_1)
   SCOPE_GUARD(_, std::bind(Platform::RemoveFileIfExists, std::cref(filename)));
   SCOPE_GUARD(rmDump, std::bind(Platform::RemoveFileIfExists, std::cref(kDumpFileName)));
 
-  std::shared_ptr<cache::IntermediateDataReader> cache;
+  std::shared_ptr<generator::cache::IntermediateDataReader> cache;
   auto c1 = std::make_shared<BoundariesCollector>(filename, kDumpFileName, cache);
 
   Collect(*c1, {placeRelation1, placeRelation2, placeRelation3, placeRelation4},
@@ -231,7 +231,7 @@ UNIT_CLASS_TEST(TestWithClassificator, CollectorRoutingCityBoundaries_2)
   SCOPE_GUARD(_, std::bind(Platform::RemoveFileIfExists, std::cref(filename)));
   SCOPE_GUARD(rmDump, std::bind(Platform::RemoveFileIfExists, std::cref(kDumpFileName)));
 
-  std::shared_ptr<cache::IntermediateDataReader> cache;
+  std::shared_ptr<generator::cache::IntermediateDataReader> cache;
   auto c1 = std::make_shared<BoundariesCollector>(filename, kDumpFileName, cache);
   auto c2 = c1->Clone();
 
@@ -329,3 +329,4 @@ UNIT_TEST(AreaOnEarth_Concave_Polygon)
                             areaOnEarth,
                             1e-6), ());
 }
+}  // namespace collector_routing_city_boundaries_tests

generator/generator_tests/cross_mwm_osm_ways_collector_tests.cpp

@@ -8,7 +8,8 @@
 
 #include "platform/platform.hpp"
 
-#include "indexer/classificator_loader.cpp"
+#include "indexer/classificator.hpp"
+#include "indexer/classificator_loader.hpp"
 
 #include "geometry/mercator.hpp"
 
@@ -23,11 +24,11 @@
 #include <utility>
 #include <vector>
 
+namespace cross_mwm_osm_ways_collector_tests
+{
 using namespace generator;
 using namespace generator_tests;
 
-namespace
-{
 std::string const kTmpDirName = "cross_mwm_ways";
 
 std::vector<std::string> const kHighwayUnclassifiedPath = {"highway", "unclassified"};
@@ -202,4 +203,4 @@ UNIT_CLASS_TEST(CrossMwmWayCollectorTest, TwoCollectorTest)
 
   Checker();
 }
-}  // namespace
+}  // namespace cross_mwm_osm_ways_collector_tests

generator/generator_tests/descriptions_section_builder_tests.cpp

@@ -28,11 +28,11 @@
 #include <utility>
 #include <vector>
 
+namespace generator_tests
+{
 using namespace generator;
 
-namespace
-{
-class Feature : public tests_support::TestFeature
+class Feature : public generator::tests_support::TestFeature
 {
 public:
   Feature() = default;
@@ -53,10 +53,7 @@ public:
 private:
   std::vector<uint32_t> m_types;
 };
-}  // namespace
 
-namespace generator_tests
-{
 class TestDescriptionSectionBuilder
 {
 public:
@@ -343,11 +340,8 @@ private:
 };
 
 std::string const TestDescriptionSectionBuilder::kMwmFile = "MwmFile";
-
 std::string const TestDescriptionSectionBuilder::kDirPages = "wiki";
-}  // namespace generator_tests
 
-using namespace generator_tests;
 
 UNIT_CLASS_TEST(TestDescriptionSectionBuilder, DescriptionsCollectionBuilder_MakeDescriptions)
 {
@@ -379,8 +373,6 @@ UNIT_CLASS_TEST(TestDescriptionSectionBuilder, DescriptionsCollectionBuilder_Bui
   TestDescriptionSectionBuilder::BuildDescriptionsSection();
 }
 
-namespace generator_tests
-{
 
 // http://en.wikipedia.org/wiki/Helsinki_Olympic_Stadium/ -  en, de, ru, fr
 // https://en.wikipedia.org/wiki/Turku_Cathedral - en, ru

generator/generator_tests/feature_builder_test.cpp

@@ -7,7 +7,7 @@
 #include "generator/geometry_holder.hpp"
 #include "generator/osm2type.hpp"
 
-#include "indexer/data_header.cpp"
+#include "indexer/data_header.hpp"
 #include "indexer/classificator_loader.hpp"
 #include "indexer/feature_visibility.hpp"
 
@@ -15,9 +15,11 @@
 
 #include <limits>
 
+namespace feature_builder_test
+{
 using namespace feature;
-
 using namespace generator::tests_support;
+using namespace std;
 using namespace tests;
 
 UNIT_CLASS_TEST(TestWithClassificator, FBuilder_ManyTypes)
@@ -343,3 +345,4 @@ UNIT_CLASS_TEST(TestWithClassificator, FBuilder_RemoveUselessAltName)
     TEST(fb.IsValid(), (fb));
   }
 }
+}  // namespace feature_builder_test

generator/generator_tests/hierarchy_entry_tests.cpp

@@ -10,11 +10,11 @@
 
 #include "base/geo_object_id.hpp"
 
+namespace hierarchy_entry_tests
+{
 using generator::tests_support::TestWithClassificator;
 using platform::tests_support::ScopedFile;
 
-namespace
-{
 std::string const kCsv1 =
     "13835058055284963881 9223372037111861697;"
     ";"
@@ -146,4 +146,4 @@ UNIT_CLASS_TEST(TestWithClassificator, Complex_LoadHierachy)
              MakeId(9223372036879747192ull, 9223372036879747192ull), ());
   TEST_EQUAL(node->GetChildren().size(), 0, ());
 }
-}  // namespace
+}  // namespace hierarchy_entry_tests

generator/generator_tests/maxspeeds_tests.cpp

@@ -2,7 +2,7 @@
 
 #include "generator/feature_builder.hpp"
 #include "generator/generator_tests/common.hpp"
-#include "generator/generator_tests_support/test_feature.cpp"
+#include "generator/generator_tests_support/test_feature.hpp"
 #include "generator/generator_tests_support/test_mwm_builder.hpp"
 #include "generator/maxspeeds_builder.hpp"
 #include "generator/maxspeeds_collector.hpp"
@@ -16,6 +16,7 @@
 
 #include "routing_common/maxspeed_conversion.hpp"
 
+#include "indexer/classificator.hpp"
 #include "indexer/classificator_loader.hpp"
 #include "indexer/data_source.hpp"
 #include "indexer/feature.hpp"
@@ -45,9 +46,8 @@
 #include <string>
 #include <vector>
 
-namespace
+namespace maxspeeds_tests
 {
-
 using namespace generator;
 using namespace generator_tests;
 using namespace measurement_utils;
@@ -137,8 +137,6 @@ bool ParseCsv(string const & maxspeedsCsvContent, OsmIdToMaxspeed & mapping)
   return ParseMaxspeeds(base::JoinPath(testDirFullPath, kCsv), mapping);
 }
 
-} // namespace
-
 UNIT_TEST(MaxspeedTagValueToSpeedTest)
 {
   SpeedInUnits speed;
@@ -408,7 +406,7 @@ UNIT_TEST(MaxspeedCollector_Smoke)
   auto const filename = GetFileName();
   SCOPE_GUARD(_, std::bind(Platform::RemoveFileIfExists, std::cref(filename)));
 
-  FeatureBuilder builder;
+  feature::FeatureBuilder builder;
 
   auto c1 = std::make_shared<MaxspeedsCollector>(filename);
   c1->CollectFeature(builder, MakeOsmElement(1 /* id */, {{"maxspeed:forward", "50"}} /* tags */, OsmElement::EntityType::Way));
@@ -438,3 +436,4 @@ UNIT_TEST(MaxspeedCollector_Smoke)
 
   TEST_EQUAL(osmIdToMaxspeed[base::MakeOsmWay(5)].GetForward(), static_cast<MaxspeedType>(20), ());
 }
+} // namespace maxspeeds_tests

generator/generator_tests/metalines_tests.cpp

@@ -20,10 +20,10 @@
 #include <string>
 #include <vector>
 
+namespace metalines_tests
+{
 using namespace feature;
 
-namespace
-{
 OsmElement MakeHighway(uint64_t id, std::string const & name, std::vector<uint64_t> const & nodes,
                        bool isOneway = false)
 {
@@ -82,7 +82,7 @@ auto const wo8 = MakeHighway(8/* id */, "w" /* name */, {17, 16, 15} /* nodes */
 
 auto const b1 = MakeHighway(1/* id */, "b" /* name */, {1, 2, 3} /* nodes */);
 auto const b2 = MakeHighway(2/* id */, "b" /* name */, {3, 4, 5} /* nodes */);
-}  // namespace
+
 
 UNIT_TEST(MetalinesTest_Case0)
 {
@@ -197,3 +197,4 @@ UNIT_TEST(MetalinesTest_MetalinesBuilderMarge)
   TEST_EQUAL(s.count({1, 2}), 1, ());
   TEST_EQUAL(s.count({4, 5}), 1, ());
 }
+}  // namespace metalines_tests

generator/generator_tests/mini_roundabout_tests.cpp

@@ -15,10 +15,10 @@
 #include <array>
 #include <vector>
 
+namespace mini_roundabout_tests
+{
 using namespace generator;
 
-namespace
-{
 OsmElement MiniRoundabout(uint64_t id, double lat, double lon)
 {
   OsmElement miniRoundabout;
@@ -49,15 +49,13 @@ OsmElement RoadNode(uint64_t id, double lat, double lon)
   return node;
 }
 
-}  // namespace
-
 void TestRunCmpPoints(std::vector<m2::PointD> const & pointsFact,
                       std::vector<m2::PointD> const & pointsPlan, double r)
 {
   TEST_EQUAL(pointsFact.size(), pointsPlan.size(), ());
   TEST_GREATER(pointsFact.size(), 2, ());
   for (size_t i = 0; i < pointsFact.size(); ++i)
-    TEST(AlmostEqualAbs(pointsFact[i], pointsPlan[i], kMwmPointAccuracy), ());
+    TEST(m2::AlmostEqualAbs(pointsFact[i], pointsPlan[i], kMwmPointAccuracy), ());
 }
 
 void TestRunCmpNumbers(double val1, double val2)
@@ -99,7 +97,7 @@ UNIT_TEST(TrimSegment_Vertical)
   double const dist = 1.0;
   m2::PointD const point = GetPointAtDistFromTarget(a /* source */, b /* target */, dist);
   m2::PointD const pointPlan(2.0, 2.0);
-  TEST(AlmostEqualAbs(point, pointPlan, kMwmPointAccuracy), ());
+  TEST(m2::AlmostEqualAbs(point, pointPlan, kMwmPointAccuracy), ());
 }
 
 UNIT_TEST(TrimSegment_VerticalNegative)
@@ -109,7 +107,7 @@ UNIT_TEST(TrimSegment_VerticalNegative)
   double const dist = 4.0;
   m2::PointD const point = GetPointAtDistFromTarget(a /* source */, b /* target */, dist);
   m2::PointD const pointPlan(-3.0, 2.0);
-  TEST(AlmostEqualAbs(point, pointPlan, kMwmPointAccuracy), ());
+  TEST(m2::AlmostEqualAbs(point, pointPlan, kMwmPointAccuracy), ());
 }
 
 UNIT_TEST(TrimSegment_ExceptionalCase)
@@ -118,7 +116,7 @@ UNIT_TEST(TrimSegment_ExceptionalCase)
   m2::PointD const b(2.0, 3.0);
   double const dist = 10.0;
   m2::PointD const point = GetPointAtDistFromTarget(a /* source */, b /* target */, dist);
-  TEST(AlmostEqualAbs(point, a, kMwmPointAccuracy), ());
+  TEST(m2::AlmostEqualAbs(point, a, kMwmPointAccuracy), ());
 }
 
 UNIT_TEST(PointToCircle_ZeroMeridian)
@@ -278,3 +276,4 @@ UNIT_TEST(Manage_MiniRoundabout_EqualPoints)
   AddPointToCircle(circlePlain, circlePlain[0]);
   TEST_EQUAL(circlePlain.size(), 16, ());
 }
+}  // namespace mini_roundabout_tests

generator/generator_tests/osm_type_test.cpp

@@ -19,67 +19,67 @@
 #include <string>
 #include <vector>
 
+namespace osm_type_test
+{
 using namespace generator::tests_support;
 using namespace tests;
 
 using Tags = std::vector<OsmElement::Tag>;
 
-namespace
+void DumpTypes(std::vector<uint32_t> const & v)
 {
-  void DumpTypes(std::vector<uint32_t> const & v)
+  Classificator const & c = classif();
+  for (size_t i = 0; i < v.size(); ++i)
+    std::cout << c.GetFullObjectName(v[i]) << std::endl;
+}
+
+void DumpParsedTypes(Tags const & tags)
+{
+  OsmElement e;
+  FillXmlElement(tags, &e);
+
+  FeatureBuilderParams params;
+  ftype::GetNameAndType(&e, params);
+
+  DumpTypes(params.m_types);
+}
+
+void TestSurfaceTypes(std::string const & surface, std::string const & smoothness,
+                      std::string const & grade, char const * value)
+{
+  OsmElement e;
+  e.AddTag("highway", "unclassified");
+  e.AddTag("surface", surface);
+  e.AddTag("smoothness", smoothness);
+  e.AddTag("surface:grade", grade);
+
+  FeatureBuilderParams params;
+  ftype::GetNameAndType(&e, params);
+
+  TEST_EQUAL(params.m_types.size(), 2, (params));
+  TEST(params.IsTypeExist(GetType({"highway", "unclassified"})), ());
+  std::string psurface;
+  for (auto type : params.m_types)
   {
-    Classificator const & c = classif();
-    for (size_t i = 0; i < v.size(); ++i)
-      std::cout << c.GetFullObjectName(v[i]) << std::endl;
+    std::string const rtype = classif().GetReadableObjectName(type);
+    if (rtype.substr(0, 9) == "psurface-")
+      psurface = rtype.substr(9);
   }
+  TEST(params.IsTypeExist(GetType({"psurface", value})),
+        ("Surface:", surface, "Smoothness:", smoothness, "Grade:", grade, "Expected:", value,
+        "Got:", psurface));
+}
 
-  void DumpParsedTypes(Tags const & tags)
-  {
-    OsmElement e;
-    FillXmlElement(tags, &e);
+FeatureBuilderParams GetFeatureBuilderParams(Tags const & tags)
+{
+  OsmElement e;
+  FillXmlElement(tags, &e);
+  FeatureBuilderParams params;
 
-    FeatureBuilderParams params;
-    ftype::GetNameAndType(&e, params);
+  ftype::GetNameAndType(&e, params);
+  return params;
+}
 
-    DumpTypes(params.m_types);
-  }
-
-  void TestSurfaceTypes(std::string const & surface, std::string const & smoothness,
-                        std::string const & grade, char const * value)
-  {
-    OsmElement e;
-    e.AddTag("highway", "unclassified");
-    e.AddTag("surface", surface);
-    e.AddTag("smoothness", smoothness);
-    e.AddTag("surface:grade", grade);
-
-    FeatureBuilderParams params;
-    ftype::GetNameAndType(&e, params);
-
-    TEST_EQUAL(params.m_types.size(), 2, (params));
-    TEST(params.IsTypeExist(GetType({"highway", "unclassified"})), ());
-    std::string psurface;
-    for (auto type : params.m_types)
-    {
-      std::string const rtype = classif().GetReadableObjectName(type);
-      if (rtype.substr(0, 9) == "psurface-")
-        psurface = rtype.substr(9);
-    }
-    TEST(params.IsTypeExist(GetType({"psurface", value})),
-         ("Surface:", surface, "Smoothness:", smoothness, "Grade:", grade, "Expected:", value,
-          "Got:", psurface));
-  }
-
-  FeatureBuilderParams GetFeatureBuilderParams(Tags const & tags)
-  {
-    OsmElement e;
-    FillXmlElement(tags, &e);
-    FeatureBuilderParams params;
-
-    ftype::GetNameAndType(&e, params);
-    return params;
-  }
-}  // namespace
 
 UNIT_CLASS_TEST(TestWithClassificator, OsmType_SkipDummy)
 {
@@ -2196,3 +2196,4 @@ UNIT_CLASS_TEST(TestWithClassificator, OsmType_ComplexTypesSmoke)
     TEST(params.IsTypeExist(GetType(type.first)), (type, params));
   }
 }
+}  // namespace osm_type_test

generator/generator_tests/restriction_test.cpp

@@ -29,16 +29,15 @@
 #include <utility>
 #include <vector>
 
-using namespace std;
-
+namespace restriction_test
+{
 using namespace feature;
 using namespace generator;
 using namespace platform::tests_support;
 using namespace platform;
 using namespace routing;
+using namespace std;
 
-namespace
-{
 // Directory name for creating test mwm and temporary files.
 string const kTestDir = "restriction_generation_test";
 // Temporary mwm name for testing.
@@ -93,8 +92,8 @@ void BuildEmptyMwm(LocalCountryFile & country)
   generator::tests_support::TestMwmBuilder builder(country, feature::DataHeader::MapType::Country);
 }
 
-void LoadRestrictions(string const & mwmFilePath, 
-                      vector<Restriction> & restrictions, 
+void LoadRestrictions(string const & mwmFilePath,
+                      vector<Restriction> & restrictions,
                       vector<RestrictionUTurnForTests> & restrictionsUTurn)
 {
   FilesContainerR const cont(mwmFilePath);
@@ -137,7 +136,7 @@ void LoadRestrictions(string const & mwmFilePath,
 /// loads the restriction section and test loaded restrictions.
 /// \param |restrictionPath| comma separated text with restrictions in osm id terms.
 /// \param |osmIdsToFeatureIdContent| comma separated text with mapping from osm ids to feature ids.
-void TestRestrictionBuilding(string const & restrictionPath,  
+void TestRestrictionBuilding(string const & restrictionPath,
                              string const & osmIdsToFeatureIdContent,
                              unique_ptr<IndexGraph> graph,
                              vector<Restriction> & expectedNotUTurn,
@@ -435,4 +434,4 @@ UNIT_TEST(RestrictionGenerationTest_WithUTurn_BadConnection_1)
   TestRestrictionBuilding(restrictionPath, osmIdsToFeatureIdsContent, move(indexGraph),
                           expectedNotUTurn, expectedUTurn);
 }
-}  // namespace
+}  // namespace restriction_test

generator/generator_tests/road_access_test.cpp

@@ -31,8 +31,8 @@
 #include <string>
 #include <vector>
 
-using namespace std;
-
+namespace road_access_test
+{
 using namespace feature;
 using namespace generator::tests_support;
 using namespace generator;
@@ -41,8 +41,6 @@ using namespace platform;
 using namespace routing;
 using namespace std;
 
-namespace
-{
 string const kTestDir = "road_access_generation_test";
 string const kTestMwm = "test";
 string const kRoadAccessFilename = "road_access_in_osm_ids.csv";
@@ -415,4 +413,4 @@ UNIT_TEST(RoadAccessWriter_Conditional_WinterRoads)
 
   TEST_EQUAL(resultFile, expectedFile, ());
 }
-}  // namespace
+}  // namespace road_access_test

generator/generator_tests/speed_cameras_test.cpp

@@ -50,6 +50,8 @@
 #include <utility>
 #include <vector>
 
+namespace speed_cameras_test
+{
 using namespace feature;
 using namespace generator;
 using namespace measurement_utils;
@@ -58,8 +60,6 @@ using namespace platform;
 using namespace routing;
 using namespace std;
 
-namespace
-{
 // Directory name for creating test mwm and temporary files.
 string const kTestDir = "speed_camera_generation_test";
 
@@ -505,4 +505,4 @@ UNIT_TEST(RoadCategoryToSpeedTest)
 
   TEST(!RoadCategoryToSpeed("UNKNOWN:unknown", speed), ());
 }
-}  // namespace
+}  // namespace speed_cameras_test

generator/generator_tool/generator_tool.cpp

@@ -12,7 +12,7 @@
 #include "generator/feature_generator.hpp"
 #include "generator/feature_sorter.hpp"
 #include "generator/generate_info.hpp"
-#include "generator/isolines_section_builder.cpp"
+#include "generator/isolines_section_builder.hpp"
 #include "generator/maxspeeds_builder.hpp"
 #include "generator/metalines_builder.hpp"
 #include "generator/osm_source.hpp"

generator/geometry_holder.hpp

@@ -31,7 +31,7 @@ public:
   // For FeatureType serialization maxNumTriangles should be less than numeric_limits<uint8_t>::max
   // because FeatureType format uses uint8_t to encode the number of triangles.
   GeometryHolder(FileGetter geoFileGetter, FileGetter trgFileGetter, FeatureBuilder & fb,
-                 feature::DataHeader const & header, size_t maxNumTriangles = 14)
+                 DataHeader const & header, size_t maxNumTriangles = 14)
     : m_geoFileGetter(geoFileGetter)
     , m_trgFileGetter(trgFileGetter)
     , m_fb(fb)
@@ -42,7 +42,7 @@ public:
   {
   }
 
-  GeometryHolder(FeatureBuilder & fb, feature::DataHeader const & header,
+  GeometryHolder(FeatureBuilder & fb, DataHeader const & header,
                  size_t maxNumTriangles = 14)
     : m_fb(fb)
     , m_ptsInner(true)

generator/hierarchy.cpp

@@ -27,12 +27,12 @@
 BOOST_GEOMETRY_REGISTER_POINT_2D(m2::PointD, double, boost::geometry::cs::cartesian, x, y);
 BOOST_GEOMETRY_REGISTER_RING(std::vector<m2::PointD>);
 
-using namespace feature;
-
 namespace generator
 {
 namespace hierarchy
 {
+using namespace feature;
+
 namespace
 {
 double CalculateOverlapPercentage(std::vector<m2::PointD> const & lhs,

generator/mini_roundabout_transformer.cpp

@@ -53,7 +53,7 @@ feature::FeatureBuilder::PointSeq::iterator GetIterOnRoad(m2::PointD const & poi
                                                           feature::FeatureBuilder::PointSeq & road)
 {
   return base::FindIf(road, [&point](m2::PointD const & pointOnRoad) {
-    return base::AlmostEqualAbs(pointOnRoad, point, kMwmPointAccuracy);
+    return m2::AlmostEqualAbs(pointOnRoad, point, kMwmPointAccuracy);
   });
 }
 }
@@ -188,7 +188,7 @@ feature::FeatureBuilder::PointSeq MiniRoundaboutTransformer::CreateSurrogateRoad
       *itPointOnSurrogateRoad /* source */, roundaboutOnRoad.m_location /* target */,
       m_radiusMercator /* dist */);
 
-  if (AlmostEqualAbs(nextPointOnSurrogateRoad, *itPointOnSurrogateRoad, kMwmPointAccuracy))
+  if (m2::AlmostEqualAbs(nextPointOnSurrogateRoad, *itPointOnSurrogateRoad, kMwmPointAccuracy))
     return {};
 
   AddPointToCircle(roundaboutCircle, nextPointOnSurrogateRoad);
@@ -214,7 +214,7 @@ bool MiniRoundaboutTransformer::AddRoundaboutToRoad(RoundaboutUnit const & round
       GetPointAtDistFromTarget(*itPointNearRoundabout /* source */, roundaboutCenter /* target */,
                                m_radiusMercator /* dist */);
 
-  if (AlmostEqualAbs(nextPointOnRoad, *itPointNearRoundabout, kMwmPointAccuracy))
+  if (m2::AlmostEqualAbs(nextPointOnRoad, *itPointNearRoundabout, kMwmPointAccuracy))
     return false;
 
   if (isMiddlePoint)
@@ -403,7 +403,7 @@ void AddPointToCircle(std::vector<m2::PointD> & circle, m2::PointD const & point
 
   if (iDist1 > iDist2)
     std::swap(iDist1, iDist2);
-  
+
   if (iDist1 == 0 && iDist2 == circle.size() - 1)
     circle.push_back(point);
   else

generator/osm_element.hpp

@@ -1,5 +1,7 @@
 #pragma once
 
+#include "geometry/mercator.hpp"  // kPointEqualityEps
+
 #include "base/assert.hpp"
 #include "base/geo_object_id.hpp"
 #include "base/math.hpp"
@@ -105,8 +107,8 @@ struct OsmElement
   {
     return m_type == other.m_type
         && m_id == other.m_id
-        && base::AlmostEqualAbs(m_lon, other.m_lon, 1e-7)
-        && base::AlmostEqualAbs(m_lat, other.m_lat, 1e-7)
+        && base::AlmostEqualAbs(m_lon, other.m_lon, mercator::kPointEqualityEps)
+        && base::AlmostEqualAbs(m_lat, other.m_lat, mercator::kPointEqualityEps)
         && m_ref == other.m_ref
         && m_k == other.m_k
         && m_v == other.m_v

generator/osm_o5m_source.hpp

@@ -131,16 +131,16 @@ public:
   {
     switch (type)
     {
-      case EntityType::End:       s << "O5M_CMD_END";
-      case EntityType::Node:      s << "O5M_CMD_NODE";
-      case EntityType::Way:       s << "O5M_CMD_WAY";
-      case EntityType::Relation:  s << "O5M_CMD_REL";
-      case EntityType::BBox:      s << "O5M_CMD_BBOX";
-      case EntityType::Timestamp: s << "O5M_CMD_TSTAMP";
-      case EntityType::Header:    s << "O5M_CMD_HEADER";
-      case EntityType::Sync:      s << "O5M_CMD_SYNC";
-      case EntityType::Jump:      s << "O5M_CMD_JUMP";
-      case EntityType::Reset:     s << "O5M_CMD_RESET";
+      case EntityType::End:       s << "O5M_CMD_END"; break;
+      case EntityType::Node:      s << "O5M_CMD_NODE"; break;
+      case EntityType::Way:       s << "O5M_CMD_WAY"; break;
+      case EntityType::Relation:  s << "O5M_CMD_REL"; break;
+      case EntityType::BBox:      s << "O5M_CMD_BBOX"; break;
+      case EntityType::Timestamp: s << "O5M_CMD_TSTAMP"; break;
+      case EntityType::Header:    s << "O5M_CMD_HEADER"; break;
+      case EntityType::Sync:      s << "O5M_CMD_SYNC"; break;
+      case EntityType::Jump:      s << "O5M_CMD_JUMP"; break;
+      case EntityType::Reset:     s << "O5M_CMD_RESET"; break;
       default: return s << "Unknown command: " << std::hex << base::Underlying(type);
     }
     return s;

generator/restriction_collector.cpp

@@ -29,7 +29,6 @@ char const kNo[] = "No";
 char const kOnly[] = "Only";
 char const kNoUTurn[] = "NoUTurn";
 char const kOnlyUTurn[] = "OnlyUTurn";
-char const kDelim[] = ", \t\r\n";
 
 bool ParseLineOfWayIds(strings::SimpleTokenizer & iter, std::vector<base::GeoObjectId> & numbers)
 {
@@ -87,7 +86,7 @@ bool RestrictionCollector::ParseRestrictions(std::string const & path)
   std::string line;
   while (std::getline(stream, line))
   {
-    strings::SimpleTokenizer iter(line, kDelim);
+    strings::SimpleTokenizer iter(line, ", \t\r\n");
     if (!iter)  // the line is empty
       return false;
 

generator/restriction_generator.cpp

@@ -4,7 +4,7 @@
 
 #include "routing/index_graph_loader.hpp"
 
-#include "routing_common/car_model.cpp"
+#include "routing_common/car_model.hpp"
 #include "routing_common/vehicle_model.hpp"
 
 #include "platform/country_file.hpp"

generator/road_access_generator.cpp

@@ -33,6 +33,8 @@
 
 #include "3party/opening_hours/opening_hours.hpp"
 
+namespace routing
+{
 using namespace feature;
 using namespace routing;
 using namespace generator;
@@ -40,8 +42,6 @@ using namespace std;
 
 namespace
 {
-char constexpr kDelim[] = " \t\r\n";
-
 using TagMapping = routing::RoadAccessTagProcessor::TagMapping;
 using ConditionalTagsList = routing::RoadAccessTagProcessor::ConditionalTagsList;
 
@@ -205,7 +205,7 @@ bool ParseRoadAccess(string const & roadAccessPath, OsmIdToFeatureIds const & os
     if (!getline(stream, line))
       break;
 
-    strings::SimpleTokenizer iter(line, kDelim);
+    strings::SimpleTokenizer iter(line, " \t\r\n");
 
     if (!iter)
     {
@@ -403,8 +403,6 @@ string GetVehicleTypeForAccessConditional(string const & accessConditionalTag)
 }
 }  // namespace
 
-namespace routing
-{
 // RoadAccessTagProcessor --------------------------------------------------------------------------
 RoadAccessTagProcessor::RoadAccessTagProcessor(VehicleType vehicleType)
     : m_vehicleType(vehicleType)

generator/routing_index_generator.cpp

@@ -400,15 +400,15 @@ void CalcCrossMwmTransitionsExperimental(
     }
     auto reader = cont.GetReader(TRANSIT_FILE_TAG);
 
-    transit::experimental::TransitData transitData;
+    ::transit::experimental::TransitData transitData;
     transitData.DeserializeForCrossMwm(*reader.GetPtr());
     auto const & stops = transitData.GetStops();
     auto const & edges = transitData.GetEdges();
 
-    auto const getStopIdPoint = [&stops](transit::TransitId stopId) {
+    auto const getStopIdPoint = [&stops](::transit::TransitId stopId) {
       auto const it = find_if(
           stops.begin(), stops.end(),
-          [stopId](transit::experimental::Stop const & stop) { return stop.GetId() == stopId; });
+          [stopId](::transit::experimental::Stop const & stop) { return stop.GetId() == stopId; });
 
       CHECK(it != stops.end(),
             ("stopId:", stopId, "is not found in stops. Size of stops:", stops.size()));

generator/translators_pool.cpp

@@ -31,7 +31,7 @@ bool TranslatorsPool::Finish()
 {
   m_threadPool.WaitingStop();
   using TranslatorPtr = std::shared_ptr<TranslatorInterface>;
-  base::threads::ThreadSafeQueue<std::future<TranslatorPtr>> queue;
+  threads::ThreadSafeQueue<std::future<TranslatorPtr>> queue;
   while (!m_translators.Empty())
   {
     std::promise<TranslatorPtr> p;

generator/translators_pool.hpp

@@ -23,6 +23,6 @@ public:
 
 private:
   base::thread_pool::computational::ThreadPool m_threadPool;
-  base::threads::ThreadSafeQueue<std::shared_ptr<TranslatorInterface>> m_translators;
+  threads::ThreadSafeQueue<std::shared_ptr<TranslatorInterface>> m_translators;
 };
 }  // namespace generator

geometry/calipers_box.cpp

@@ -23,7 +23,7 @@ static_assert(numeric_limits<double>::has_infinity, "");
 double const kInf = numeric_limits<double>::infinity();
 
 // Checks whether (p1 - p) x (p2 - p) >= 0.
-bool IsCCW(PointD const & p1, PointD const & p2, PointD const & p, double eps)
+bool IsCCWNeg(PointD const & p1, PointD const & p2, PointD const & p, double eps)
 {
   return robust::OrientedS(p1, p2, p) > -eps;
 }
@@ -137,7 +137,7 @@ bool CalipersBox::HasPoint(PointD const & p, double eps) const
   {
     auto const & a = m_points[i];
     auto const & b = m_points[(i + 1) % n];
-    if (!IsCCW(b, p, a, eps))
+    if (!IsCCWNeg(b, p, a, eps))
       return false;
   }
   return true;

geometry/geometry_tests/algorithm_test.cpp

@@ -1,6 +1,7 @@
 #include "testing/testing.hpp"
 
 #include "geometry/algorithm.hpp"
+#include "geometry/mercator.hpp"
 
 #include "base/assert.hpp"
 
@@ -35,7 +36,7 @@ PointD GetPointOnSurface(vector<PointD> const & points)
 
 bool PointsAlmostEqual(PointD const & p1, PointD const & p2)
 {
-  return p1.EqualDxDy(p2, 1e-7);
+  return p1.EqualDxDy(p2, mercator::kPointEqualityEps);
 }
 }  // namespace
 

geometry/geometry_tests/angle_test.cpp

@@ -52,7 +52,7 @@ namespace
 
 UNIT_TEST(Average)
 {
-  double const eps = 1.0E-3;
+  double constexpr eps = 1.0E-3;
 
   double arr1[] = { math::pi-eps, -math::pi+eps };
   TEST(is_equal_angle(ang::GetMiddleAngle(arr1[0], arr1[1]), math::pi), ());
@@ -74,7 +74,7 @@ UNIT_TEST(ShortestDistance)
 
 UNIT_TEST(TwoVectorsAngle)
 {
-  double const eps = 1e-10;
+  double constexpr eps = 1e-10;
   TEST(base::AlmostEqualAbs(ang::TwoVectorsAngle(m2::Point<double>(0, 0)  /* p */,
                                                  m2::Point<double>(0, 1)  /* p1 */,
                                                  m2::Point<double>(1, 0)) /* p2 */, 3 * math::pi2, eps), ());

geometry/geometry_tests/covering_test.cpp

@@ -11,6 +11,8 @@
 
 // TODO: Add covering unit tests here.
 
+namespace covering_test
+{
 using namespace std;
 
 using CellId = m2::CellId<5>;
@@ -135,3 +137,4 @@ UNIT_TEST(Covering_Simplify_Smoke)
   e.push_back(CellId("0012"));
   TEST_EQUAL(v, e, ());
 }
+}  // namespace covering_test

geometry/geometry_tests/line2d_tests.cpp

@@ -4,10 +4,10 @@
 #include "geometry/point2d.hpp"
 #include "geometry/segment2d.hpp"
 
+namespace line2d_tests
+{
 using namespace m2;
 
-namespace
-{
 double const kEps = 1e-12;
 
 using Result = IntersectionResult;
@@ -45,4 +45,4 @@ UNIT_TEST(LineIntersection_Smoke)
     TEST(AlmostEqualAbs(result.m_point, PointD(0, 100), kEps), (result.m_point));
   }
 }
-}  // namespace
+}  // namespace line2d_tests

geometry/geometry_tests/polyline_tests.cpp

@@ -8,7 +8,7 @@
 
 #include <vector>
 
-namespace
+namespace polyline_tests
 {
 double constexpr kEps = 1e-5;
 
@@ -56,4 +56,4 @@ UNIT_TEST(Rect_PolylineMinDistanceTest)
   TestClosest(poly, m2::PointD(1.5, 5.0), 4.0 * 4.0 + 1.5 * 1.5 /* expectedSquaredDist */, 0 /* expectedIndex */);
   TestClosest(poly, m2::PointD(3.0, 1.0), 0.0 /* expectedSquaredDist */, 4 /* expectedIndex */);
 }
-}  // namespace
+}  // namespace polyline_tests

geometry/geometry_tests/region2d_binary_op_test.cpp

@@ -7,13 +7,11 @@
 
 #include <vector>
 
-using namespace std;
-
-namespace
+namespace region2d_binary_op_test
 {
+using namespace std;
 using P = m2::PointI;
 using R = m2::RegionI;
-}  // namespace
 
 UNIT_TEST(RegionIntersect_Smoke)
 {
@@ -166,3 +164,4 @@ UNIT_TEST(RegionDifference_Data1)
   }
 }
 */
+}  // namespace region2d_binary_op_test

geometry/geometry_tests/segment2d_tests.cpp

@@ -3,10 +3,10 @@
 #include "geometry/point2d.hpp"
 #include "geometry/segment2d.hpp"
 
+namespace segment2d_tests
+{
 using namespace m2;
 
-namespace
-{
 double const kEps = 1e-10;
 
 void TestIntersectionResult(IntersectionResult const & result, IntersectionResult::Type expectedType,
@@ -105,4 +105,4 @@ UNIT_TEST(SegmentIntersection_InfinityIntersectionPoints)
       Intersect(Segment2D({0.0, 0.0}, {2.0, 4.0}), Segment2D({1.0, 2.0}, {2.0, 4.0}), kEps).m_type,
       IntersectionResult::Type::Infinity, ());
 }
-}  // namespace
+}  // namespace segment2d_tests

geometry/geometry_tests/tree_test.cpp

@@ -4,10 +4,9 @@
 
 #include <functional>
 
-using namespace std;
-
-namespace
+namespace tree_test
 {
+using namespace std;
 using R = m2::RectD;
 
 struct traits_t
@@ -28,7 +27,6 @@ bool RFalse(T const &, T const &)
 {
   return false;
 }
-}  // namespace
 
 UNIT_TEST(Tree4D_Smoke)
 {
@@ -139,8 +137,6 @@ UNIT_TEST(Tree4D_ForEachInRect)
   CheckInRect(arr, ARRAY_SIZE(arr), R(-5.5, -5.5, -0.5, -0.5), 2);
 }
 
-namespace
-{
 struct TestObj : public m2::RectD
 {
   int m_id;
@@ -152,7 +148,6 @@ struct TestObj : public m2::RectD
 
   bool operator==(TestObj const & r) const { return m_id == r.m_id; }
 };
-}
 
 UNIT_TEST(Tree4D_ReplaceEqual)
 {
@@ -189,3 +184,4 @@ UNIT_TEST(Tree4D_ReplaceEqual)
   i = find(test.begin(), test.end(), T(1, 1, 2, 2, 2));
   TEST_EQUAL(R(*i), R(0, 0, 3, 3), ());
 }
+}  // namespace tree_test

geometry/mercator.hpp

@@ -8,6 +8,8 @@
 
 namespace mercator
 {
+// Use to compare/match lat lon coordinates.
+static double constexpr kPointEqualityEps = 1e-7;
 struct Bounds
 {
   static double constexpr kMinX = -180.0;

geometry/point2d.hpp

@@ -235,7 +235,7 @@ std::string DebugPrint(m2::Point<T> const & p)
 }
 
 template <typename T>
-bool AlmostEqualAbs(m2::Point<T> const & a, m2::Point<T> const & b, double const eps)
+bool AlmostEqualAbs(m2::Point<T> const & a, m2::Point<T> const & b, double eps)
 {
   return base::AlmostEqualAbs(a.x, b.x, eps) && base::AlmostEqualAbs(a.y, b.y, eps);
 }
@@ -309,7 +309,7 @@ bool AlmostEqualULPs(m2::Point<T> const & p1, m2::Point<T> const & p2, unsigned
 }
 
 template <typename T>
-bool AlmostEqualAbs(m2::Point<T> const & p1, m2::Point<T> const & p2, double const & eps)
+bool AlmostEqualAbs(m2::Point<T> const & p1, m2::Point<T> const & p2, double eps)
 {
   return m2::AlmostEqualAbs(p1, p2, eps);
 }

geometry/polygon.hpp

@@ -134,7 +134,7 @@ public:
   }
 };
 
-namespace detail
+namespace polygon_detail
 {
   template <typename F> class StripEmitter
   {
@@ -164,11 +164,11 @@ namespace detail
 
 /// Make single strip for the range of points [beg, end), started with index = i.
 template <typename F>
-void MakeSingleStripFromIndex(size_t i, size_t n, F f)
+void MakeSingleStripFromIndex(size_t i, size_t n, F && f)
 {
   ASSERT_LESS(i, n, ());
   f(i);
-  FindSingleStripForIndex(i, n, detail::StripEmitter<F>(f));
+  FindSingleStripForIndex(i, n, polygon_detail::StripEmitter<F>(f));
 }
 
 template <class TIter> double GetPolygonArea(TIter beg, TIter end)

geometry/simplification.hpp

@@ -17,7 +17,7 @@
 // SimplifyXXX() should be used to simplify polyline for a given epsilon.
 // (!) They do not include the last point to the simplification, the calling side should do it.
 
-namespace impl
+namespace simpl
 {
 ///@name This functions take input range NOT like STL does: [first, last].
 //@{
@@ -45,15 +45,15 @@ std::pair<double, Iter> MaxDistance(Iter first, Iter last, DistanceFn & distFn)
 template <typename DistanceFn, typename Iter, typename Out>
 void SimplifyDP(Iter first, Iter last, double epsilon, DistanceFn & distFn, Out & out)
 {
-  std::pair<double, Iter> maxDist = impl::MaxDistance(first, last, distFn);
+  std::pair<double, Iter> maxDist = MaxDistance(first, last, distFn);
   if (maxDist.second == last || maxDist.first < epsilon)
   {
     out(*last);
   }
   else
   {
-    impl::SimplifyDP(first, maxDist.second, epsilon, distFn, out);
-    impl::SimplifyDP(maxDist.second, last, epsilon, distFn, out);
+    simpl::SimplifyDP(first, maxDist.second, epsilon, distFn, out);
+    simpl::SimplifyDP(maxDist.second, last, epsilon, distFn, out);
   }
 }
 //@}
@@ -67,7 +67,7 @@ struct SimplifyOptimalRes
   int32_t m_NextPoint = -1;
   uint32_t m_PointCount = -1U;
 };
-}  // namespace impl
+}  // namespace simpl
 
 // Douglas-Peucker algorithm for STL-like range [beg, end).
 // Iteratively includes the point with max distance from the current simplification.
@@ -78,7 +78,7 @@ void SimplifyDP(Iter beg, Iter end, double epsilon, DistanceFn distFn, Out out)
   if (beg != end)
   {
     out(*beg);
-    impl::SimplifyDP(beg, end - 1, epsilon, distFn, out);
+    simpl::SimplifyDP(beg, end - 1, epsilon, distFn, out);
   }
 }
 
@@ -100,8 +100,8 @@ void SimplifyNearOptimal(int maxFalseLookAhead, Iter beg, Iter end, double epsil
     return;
   }
 
-  std::vector<impl::SimplifyOptimalRes> F(n);
-  F[n - 1] = impl::SimplifyOptimalRes(n, 1);
+  std::vector<simpl::SimplifyOptimalRes> F(n);
+  F[n - 1] = simpl::SimplifyOptimalRes(n, 1);
   for (int32_t i = n - 2; i >= 0; --i)
   {
     for (int32_t falseCount = 0, j = i + 1; j < n && falseCount < maxFalseLookAhead; ++j)
@@ -109,7 +109,7 @@ void SimplifyNearOptimal(int maxFalseLookAhead, Iter beg, Iter end, double epsil
       uint32_t const newPointCount = F[j].m_PointCount + 1;
       if (newPointCount < F[i].m_PointCount)
       {
-        if (impl::MaxDistance(beg + i, beg + j, distFn).first < epsilon)
+        if (simpl::MaxDistance(beg + i, beg + j, distFn).first < epsilon)
         {
           F[i].m_NextPoint = j;
           F[i].m_PointCount = newPointCount;

indexer/CMakeLists.txt

@@ -150,6 +150,7 @@ omim_add_library(${PROJECT_NAME} ${SRC})
 add_subdirectory(${OMIM_ROOT}/3party/protobuf ${CMAKE_CURRENT_BINARY_DIR}/protobuf)
 
 target_link_libraries(${PROJECT_NAME}
+  search  # search::DummyRankTable in CachingRankTableLoader
   platform
   geometry
   protobuf

indexer/categories_holder.cpp

@@ -13,7 +13,7 @@ using namespace std;
 
 namespace
 {
-enum State
+enum ParseState
 {
   EParseTypes,
   EParseLanguages
@@ -194,7 +194,7 @@ void CategoriesHolder::LoadFromStream(istream & s)
   m_name2type.Clear();
   m_groupTranslations.clear();
 
-  State state = EParseTypes;
+  ParseState state = EParseTypes;
   string line;
   Category cat;
   vector<uint32_t> types;

indexer/classificator.cpp

@@ -123,18 +123,11 @@ void ClassifObject::ConcatChildNames(string & s) const
 // Classificator implementation
 /////////////////////////////////////////////////////////////////////////////////////////
 
-namespace
-{
-Classificator & classif(MapStyle mapStyle)
-{
-  static Classificator c[MapStyleCount];
-  return c[mapStyle];
-}
-} // namespace
-
 Classificator & classif()
 {
-  return classif(GetStyleReader().GetCurrentStyle());
+  static Classificator c[MapStyleCount];
+  MapStyle const mapStyle = GetStyleReader().GetCurrentStyle();
+  return c[mapStyle];
 }
 
 namespace ftype

indexer/indexer_tests/bounds.hpp

@@ -1,3 +1,5 @@
+#pragma once
+
 #include "geometry/rect2d.hpp"
 
 template <int MinX, int MinY, int MaxX, int MaxY>

indexer/indexer_tests/complex_serdes_tests.cpp

@@ -9,25 +9,26 @@
 #include <cstdint>
 #include <vector>
 
-namespace
+namespace complex_serdes_tests
 {
 using ByteVector = std::vector<uint8_t>;
+using ::complex::ComplexSerdes;
 
 decltype(auto) GetForest()
 {
-  auto tree1 = tree_node::MakeTreeNode<complex::ComplexSerdes::Ids>({1, 2, 3});
-  auto node11 = tree_node::MakeTreeNode<complex::ComplexSerdes::Ids>({11, 12, 13});
-  tree_node::Link(tree_node::MakeTreeNode<complex::ComplexSerdes::Ids>({111}), node11);
-  tree_node::Link(tree_node::MakeTreeNode<complex::ComplexSerdes::Ids>({112, 113}), node11);
-  tree_node::Link(tree_node::MakeTreeNode<complex::ComplexSerdes::Ids>({114}), node11);
+  auto tree1 = tree_node::MakeTreeNode<ComplexSerdes::Ids>({1, 2, 3});
+  auto node11 = tree_node::MakeTreeNode<ComplexSerdes::Ids>({11, 12, 13});
+  tree_node::Link(tree_node::MakeTreeNode<ComplexSerdes::Ids>({111}), node11);
+  tree_node::Link(tree_node::MakeTreeNode<ComplexSerdes::Ids>({112, 113}), node11);
+  tree_node::Link(tree_node::MakeTreeNode<ComplexSerdes::Ids>({114}), node11);
   tree_node::Link(node11, tree1);
-  tree_node::Link(tree_node::MakeTreeNode<complex::ComplexSerdes::Ids>({6, 7}), tree1);
+  tree_node::Link(tree_node::MakeTreeNode<ComplexSerdes::Ids>({6, 7}), tree1);
 
-  auto tree2 = tree_node::MakeTreeNode<complex::ComplexSerdes::Ids>({9});
-  tree_node::Link(tree_node::MakeTreeNode<complex::ComplexSerdes::Ids>({21, 22, 23}), tree2);
-  tree_node::Link(tree_node::MakeTreeNode<complex::ComplexSerdes::Ids>({24, 25}), tree2);
+  auto tree2 = tree_node::MakeTreeNode<ComplexSerdes::Ids>({9});
+  tree_node::Link(tree_node::MakeTreeNode<ComplexSerdes::Ids>({21, 22, 23}), tree2);
+  tree_node::Link(tree_node::MakeTreeNode<ComplexSerdes::Ids>({24, 25}), tree2);
 
-  tree_node::Forest<complex::ComplexSerdes::Ids> forest;
+  tree_node::Forest<ComplexSerdes::Ids> forest;
   forest.Append(tree1);
   forest.Append(tree2);
   return forest;
@@ -40,13 +41,13 @@ UNIT_TEST(Complex_SerdesV0)
   {
     MemWriter<decltype(buffer)> writer(buffer);
     WriterSink<decltype(writer)> sink(writer);
-    complex::ComplexSerdes::Serialize(sink, complex::ComplexSerdes::Version::V0, expectedForest);
+    ComplexSerdes::Serialize(sink, ComplexSerdes::Version::V0, expectedForest);
   }
   {
     MemReader reader(buffer.data(), buffer.size());
     ReaderSource<decltype(reader)> src(reader);
-    tree_node::Forest<complex::ComplexSerdes::Ids> forest;
-    complex::ComplexSerdes::Deserialize(src, complex::ComplexSerdes::Version::V0, forest);
+    tree_node::Forest<ComplexSerdes::Ids> forest;
+    ComplexSerdes::Deserialize(src, ComplexSerdes::Version::V0, forest);
     TEST_EQUAL(forest, expectedForest, ());
   }
 }
@@ -58,13 +59,13 @@ UNIT_TEST(Complex_Serdes)
   {
     MemWriter<decltype(buffer)> writer(buffer);
     WriterSink<decltype(writer)> sink(writer);
-    complex::ComplexSerdes::Serialize(sink, expectedForest);
+    ComplexSerdes::Serialize(sink, expectedForest);
   }
   {
     MemReader reader(buffer.data(), buffer.size());
-    tree_node::Forest<complex::ComplexSerdes::Ids> forest;
-    complex::ComplexSerdes::Deserialize(reader, forest);
+    tree_node::Forest<ComplexSerdes::Ids> forest;
+    ComplexSerdes::Deserialize(reader, forest);
     TEST_EQUAL(forest, expectedForest, ());
   }
 }
-}  // namespace
+}  // namespace complex_serdes_tests

indexer/indexer_tests/mwm_set_test.cpp

@@ -1,9 +1,8 @@
 #include "testing/testing.hpp"
 
-#include "platform/platform_tests_support/scoped_mwm.cpp"
+#include "platform/platform_tests_support/scoped_mwm.hpp"
 
 #include "indexer/indexer_tests/test_mwm_set.hpp"
-
 #include "indexer/mwm_set.hpp"
 
 #include "base/macros.hpp"
@@ -11,16 +10,16 @@
 #include <initializer_list>
 #include <unordered_map>
 
+namespace mwm_set_test
+{
+using namespace platform::tests_support;
 using namespace std;
 using platform::CountryFile;
 using platform::LocalCountryFile;
 using tests::TestMwmSet;
-using namespace platform::tests_support;
 
 using MwmsInfo = unordered_map<string, shared_ptr<MwmInfo>>;
 
-namespace
-{
 void GetMwmsInfo(MwmSet const & mwmSet, MwmsInfo & mwmsInfo)
 {
   vector<shared_ptr<MwmInfo>> mwmsInfoList;
@@ -37,7 +36,6 @@ void TestFilesPresence(MwmsInfo const & mwmsInfo, initializer_list<string> const
   for (string const & countryFileName : expectedNames)
     TEST_EQUAL(1, mwmsInfo.count(countryFileName), (countryFileName));
 }
-}  // namespace
 
 UNIT_TEST(MwmSetSmokeTest)
 {
@@ -171,3 +169,4 @@ UNIT_TEST(MwmSetLockAndIdTest)
   TEST(!handle.GetId().IsAlive(), ());
   TEST(!handle.GetId().GetInfo().get(), ());
 }
+}  // namespace mwm_set_test

iphone/Maps/Classes/FirstSession.h

@@ -25,9 +25,10 @@
 #ifndef FIRSTSESSION_H
 #define FIRSTSESSION_H
 
+#import <CoreLocation/CoreLocation.h>
 #import <Foundation/Foundation.h>
 #import <Foundation/NSDate.h>
-#import <CoreLocation/CoreLocation.h>
+#import <TargetConditionals.h> // TARGET_OS_IPHONE
 
 #if (TARGET_OS_IPHONE > 0)
 #import <UIKit/UIApplication.h> // enum UIBackgroundFetchResult

iphone/Maps/Classes/FirstSession.mm

@@ -30,7 +30,6 @@
 
 #include <utility> // std::pair
 #include <sys/xattr.h>
-#include <TargetConditionals.h> // TARGET_OS_IPHONE
 
 #import <CoreFoundation/CoreFoundation.h>
 #import <CoreFoundation/CFURL.h>

iphone/Maps/main.mm

@@ -1,15 +1,10 @@
 #import "MapsAppDelegate.h"
 
-#include "platform/file_logging.hpp"
 #include "platform/platform.hpp"
 #include "platform/settings.hpp"
 
-
 int main(int argc, char * argv[])
 {
-#ifdef MWM_LOG_TO_FILE
-  base::SetLogMessageFn(LogMessageFile);
-#endif
   auto & p = GetPlatform();
   LOG(LINFO, ("Organic Maps started, detected CPU cores:", p.CpuCores()));
 

map/gps_track.cpp

@@ -8,7 +8,7 @@
 using namespace std;
 using namespace std::chrono;
 
-namespace
+namespace gps_track
 {
 
 inline pair<size_t, size_t> UnionRanges(pair<size_t, size_t> const & a, pair<size_t, size_t> const & b)
@@ -30,7 +30,7 @@ inline pair<size_t, size_t> UnionRanges(pair<size_t, size_t> const & a, pair<siz
 
 size_t constexpr kItemBlockSize = 1000;
 
-} // namespace
+} // namespace gps_track
 
 size_t const GpsTrack::kInvalidId = GpsTrackCollection::kInvalidId;
 
@@ -181,7 +181,7 @@ void GpsTrack::InitCollection(hours duration)
     // and filtered points are inserted in the runtime collection.
 
     vector<location::GpsInfo> originPoints;
-    originPoints.reserve(kItemBlockSize);
+    originPoints.reserve(gps_track::kItemBlockSize);
 
     m_storage->ForEach([this, &originPoints](location::GpsInfo const & originPoint)->bool
     {
@@ -301,7 +301,8 @@ void GpsTrack::UpdateCollection(hours duration, bool needClear, vector<location:
   else
     addedIds = make_pair(kInvalidId, kInvalidId);
 
-  evictedIds = UnionRanges(evictedIdsByAdd, UnionRanges(evictedIdsByClear, evictedIdsByDuration));
+  evictedIds = gps_track::UnionRanges(evictedIdsByAdd,
+                                      gps_track::UnionRanges(evictedIdsByClear, evictedIdsByDuration));
 }
 
 void GpsTrack::NotifyCallback(pair<size_t, size_t> const & addedIds, pair<size_t, size_t> const & evictedIds)

map/map_tests/gps_track_storage_test.cpp

@@ -16,12 +16,11 @@
 #include <string>
 #include <vector>
 
+namespace gps_track_storage_test
+{
 using namespace std;
 using namespace std::chrono;
 
-namespace
-{
-
 location::GpsInfo Make(double timestamp, ms::LatLon const & ll, double speed)
 {
   location::GpsInfo info;
@@ -38,8 +37,6 @@ inline string GetGpsTrackFilePath()
   return base::JoinPath(GetPlatform().WritableDir(), "gpstrack_test.bin");
 }
 
-} // namespace
-
 UNIT_TEST(GpsTrackStorage_WriteReadWithoutTrunc)
 {
   time_t const t = system_clock::to_time_t(system_clock::now());
@@ -189,3 +186,4 @@ UNIT_TEST(GpsTrackStorage_WriteReadWithTrunc)
     TEST_EQUAL(i, 0, ());
   }
 }
+} // namespace gps_track_storage_test

map/map_tests/gps_track_test.cpp

@@ -17,12 +17,11 @@
 #include <utility>
 #include <vector>
 
+namespace gps_track_test
+{
 using namespace std;
 using namespace std::chrono;
 
-namespace
-{
-
 inline location::GpsInfo Make(double timestamp, ms::LatLon const & ll, double speed)
 {
   location::GpsInfo info;
@@ -83,8 +82,6 @@ private:
 
 seconds const kWaitForCallbackTimeout = seconds(5);
 
-} // namespace
-
 UNIT_TEST(GpsTrack_Simple)
 {
   string const filePath = GetGpsTrackFilePath();
@@ -205,3 +202,4 @@ UNIT_TEST(GpsTrack_EvictedByAdd)
   TEST_EQUAL(callback.m_toRemove.first, 0, ());
   TEST_EQUAL(callback.m_toRemove.second, 0, ());
 }
+} // namespace gps_track_test