[base] Replaced the namespace my with base.

3party/bsdiff-courgette/bsdiff/bsdiff.h

@@ -125,7 +125,7 @@ BSDiffStatus CreateBinaryPatch(OldReader & old_reader,
 
   auto initial_patch_sink_pos = patch_sink.Pos();
 
-  my::Timer bsdiff_timer;
+  base::Timer bsdiff_timer;
 
   CHECK_GREATER_OR_EQUAL(kNumStreams, 6, ());
   std::array<MemStream, kNumStreams> mem_streams;
@@ -148,7 +148,7 @@ BSDiffStatus CreateBinaryPatch(OldReader & old_reader,
     return MEM_ERROR;
   }
 
-  my::Timer suf_sort_timer;
+  base::Timer suf_sort_timer;
   divsuf::saint_t result = divsuf::divsufsort_include_empty(
       old, I.begin(), old_size);
   LOG(LINFO, ("Done divsufsort", suf_sort_timer.ElapsedSeconds()));

3party/jansson/jansson_handle.cpp

@@ -1,11 +1,9 @@
-#include "jansson_handle.hpp"
+#include "3party/jansson/jansson_handle.hpp"
 
 #include <jansson.h>
 
-
-namespace my
+namespace base
 {
-
 void JsonHandle::IncRef()
 {
   if (m_pJson)
@@ -17,5 +15,4 @@ void JsonHandle::DecRef()
   if (m_pJson)
     json_decref(m_pJson);
 }
-
-}
+}  // namespace base

3party/jansson/jansson_handle.hpp

@@ -2,12 +2,10 @@
 
 #include "std/algorithm.hpp"
 
-
 struct json_struct_t;
 
-namespace my
+namespace base
 {
-
 class JsonHandle
 {
   void IncRef();
@@ -67,5 +65,4 @@ class JsonHandle
 private:
   json_struct_t * m_pJson;
 };
-
-}
+}  // namespace base

3party/jansson/myjansson.cpp

@@ -15,37 +15,37 @@ string FromJSONToString(json_t * root)
 }
 }  // namespace
 
-namespace my
+namespace base
 {
 json_t * GetJSONObligatoryField(json_t * root, std::string const & field)
 {
-  auto * value = my::GetJSONOptionalField(root, field);
+  auto * value = base::GetJSONOptionalField(root, field);
   if (!value)
-    MYTHROW(my::Json::Exception, ("Obligatory field", field, "is absent."));
+    MYTHROW(base::Json::Exception, ("Obligatory field", field, "is absent."));
   return value;
 }
 
 json_t * GetJSONOptionalField(json_t * root, std::string const & field)
 {
   if (!json_is_object(root))
-    MYTHROW(my::Json::Exception, ("Bad json object while parsing", field));
+    MYTHROW(base::Json::Exception, ("Bad json object while parsing", field));
   return json_object_get(root, field.c_str());
 }
 
 bool JSONIsNull(json_t * root) { return json_is_null(root); }
-}  // namespace my
+}  // namespace base
 
 void FromJSON(json_t * root, double & result)
 {
   if (!json_is_number(root))
-    MYTHROW(my::Json::Exception, ("Object must contain a json number."));
+    MYTHROW(base::Json::Exception, ("Object must contain a json number."));
   result = json_number_value(root);
 }
 
 void FromJSON(json_t * root, bool & result)
 {
   if (!json_is_true(root) && !json_is_false(root) )
-    MYTHROW(my::Json::Exception, ("Object must contain a boolean value."));
+    MYTHROW(base::Json::Exception, ("Object must contain a boolean value."));
   result = json_is_true(root);
 }
 
@@ -63,15 +63,15 @@ string FromJSONToString(json_t * root)
   if (json_is_boolean(root))
     return FromJSONToString<bool>(root);
 
-  MYTHROW(my::Json::Exception, ("Unexpected json type"));
+  MYTHROW(base::Json::Exception, ("Unexpected json type"));
 }
 
 namespace std
 {
 void FromJSON(json_t * root, string & result)
 {
   if (!json_is_string(root))
-    MYTHROW(my::Json::Exception, ("The field must contain a json string."));
+    MYTHROW(base::Json::Exception, ("The field must contain a json string."));
   result = json_string_value(root);
 }
 }  // namespace std
@@ -85,5 +85,5 @@ void FromJSON(json_t * root, UniString & result)
   result = MakeUniString(s);
 }
 
-my::JSONPtr ToJSON(UniString const & s) { return ToJSON(ToUtf8(s)); }
+base::JSONPtr ToJSON(UniString const & s) { return ToJSON(ToUtf8(s)); }
 }  // namespace strings

3party/jansson/myjansson.hpp

@@ -12,7 +12,7 @@
 
 #include "3party/jansson/src/jansson.h"
 
-namespace my
+namespace base
 {
 struct JSONDecRef
 {
@@ -57,7 +57,7 @@ class Json
 json_t * GetJSONObligatoryField(json_t * root, std::string const & field);
 json_t * GetJSONOptionalField(json_t * root, std::string const & field);
 bool JSONIsNull(json_t * root);
-}  // namespace my
+}  // namespace base
 
 inline void FromJSON(json_t * root, json_t *& value) { value = root; }
 
@@ -69,7 +69,7 @@ template <typename T,
 void FromJSON(json_t * root, T & result)
 {
   if (!json_is_number(root))
-    MYTHROW(my::Json::Exception, ("Object must contain a json number."));
+    MYTHROW(base::Json::Exception, ("Object must contain a json number."));
   result = static_cast<T>(json_integer_value(root));
 }
 
@@ -78,21 +78,21 @@ std::string FromJSONToString(json_t * root);
 template <typename T>
 void FromJSONObject(json_t * root, std::string const & field, T & result)
 {
-  auto * json = my::GetJSONObligatoryField(root, field);
+  auto * json = base::GetJSONObligatoryField(root, field);
   try
   {
     FromJSON(json, result);
   }
-  catch (my::Json::Exception const & e)
+  catch (base::Json::Exception const & e)
   {
-    MYTHROW(my::Json::Exception, ("An error occured while parsing field", field, e.Msg()));
+    MYTHROW(base::Json::Exception, ("An error occured while parsing field", field, e.Msg()));
   }
 }
 
 template <typename T>
 void FromJSONObjectOptionalField(json_t * root, std::string const & field, T & result)
 {
-  auto * json = my::GetJSONOptionalField(root, field);
+  auto * json = base::GetJSONOptionalField(root, field);
   if (!json)
   {
     result = T{};
@@ -103,18 +103,18 @@ void FromJSONObjectOptionalField(json_t * root, std::string const & field, T & r
 
 template <typename T,
           typename std::enable_if<std::is_integral<T>::value, void>::type* = nullptr>
-inline my::JSONPtr ToJSON(T value) { return my::NewJSONInt(value); }
-inline my::JSONPtr ToJSON(double value) { return my::NewJSONReal(value); }
-inline my::JSONPtr ToJSON(bool value) { return my::NewJSONBool(value); }
-inline my::JSONPtr ToJSON(char const * s) { return my::NewJSONString(s); }
+inline base::JSONPtr ToJSON(T value) { return base::NewJSONInt(value); }
+inline base::JSONPtr ToJSON(double value) { return base::NewJSONReal(value); }
+inline base::JSONPtr ToJSON(bool value) { return base::NewJSONBool(value); }
+inline base::JSONPtr ToJSON(char const * s) { return base::NewJSONString(s); }
 
 template <typename T>
 void ToJSONArray(json_t & root, T const & value)
 {
   json_array_append_new(&root, ToJSON(value).release());
 }
 
-inline void ToJSONArray(json_t & parent, my::JSONPtr & child)
+inline void ToJSONArray(json_t & parent, base::JSONPtr & child)
 {
   json_array_append_new(&parent, child.release());
 }
@@ -130,7 +130,7 @@ void ToJSONObject(json_t & root, std::string const & field, T const & value)
   json_object_set_new(&root, field.c_str(), ToJSON(value).release());
 }
 
-inline void ToJSONObject(json_t & parent, std::string const & field, my::JSONPtr & child)
+inline void ToJSONObject(json_t & parent, std::string const & field, base::JSONPtr & child)
 {
   json_object_set_new(&parent, field.c_str(), child.release());
 }
@@ -143,9 +143,9 @@ inline void ToJSONObject(json_t & parent, std::string const & field, json_t & ch
 template <typename T>
 void FromJSONObject(json_t * root, std::string const & field, std::vector<T> & result)
 {
-  auto * arr = my::GetJSONObligatoryField(root, field);
+  auto * arr = base::GetJSONObligatoryField(root, field);
   if (!json_is_array(arr))
-    MYTHROW(my::Json::Exception, ("The field", field, "must contain a json array."));
+    MYTHROW(base::Json::Exception, ("The field", field, "must contain a json array."));
   size_t sz = json_array_size(arr);
   result.resize(sz);
   for (size_t i = 0; i < sz; ++i)
@@ -161,14 +161,14 @@ void FromJSONObject(json_t * root, std::string const & field, std::vector<T> & r
 template <typename T>
 bool FromJSONObjectOptional(json_t * root, std::string const & field, std::vector<T> & result)
 {
-  auto * arr = my::GetJSONOptionalField(root, field);
-  if (!arr || my::JSONIsNull(arr))
+  auto * arr = base::GetJSONOptionalField(root, field);
+  if (!arr || base::JSONIsNull(arr))
   {
     result.clear();
     return false;
   }
   if (!json_is_array(arr))
-    MYTHROW(my::Json::Exception, ("The field", field, "must contain a json array."));
+    MYTHROW(base::Json::Exception, ("The field", field, "must contain a json array."));
   size_t const sz = json_array_size(arr);
   result.resize(sz);
   for (size_t i = 0; i < sz; ++i)
@@ -179,7 +179,7 @@ bool FromJSONObjectOptional(json_t * root, std::string const & field, std::vecto
 template <typename T>
 void ToJSONObject(json_t & root, std::string const & field, std::vector<T> const & values)
 {
-  auto arr = my::NewJSONArray();
+  auto arr = base::NewJSONArray();
   for (auto const & value : values)
     json_array_append_new(arr.get(), ToJSON(value).release());
   json_object_set_new(&root, field.c_str(), arr.release());
@@ -188,14 +188,14 @@ void ToJSONObject(json_t & root, std::string const & field, std::vector<T> const
 template <typename T>
 void FromJSONObjectOptionalField(json_t * root, std::string const & field, std::vector<T> & result)
 {
-  json_t * arr = my::GetJSONOptionalField(root, field);
+  json_t * arr = base::GetJSONOptionalField(root, field);
   if (!arr)
   {
     result.clear();
     return;
   }
   if (!json_is_array(arr))
-    MYTHROW(my::Json::Exception, ("The field", field, "must contain a json array."));
+    MYTHROW(base::Json::Exception, ("The field", field, "must contain a json array."));
   size_t sz = json_array_size(arr);
   result.resize(sz);
   for (size_t i = 0; i < sz; ++i)
@@ -210,11 +210,11 @@ struct JSONFreeDeleter
 namespace std
 {
 void FromJSON(json_t * root, std::string & result);
-inline my::JSONPtr ToJSON(std::string const & s) { return my::NewJSONString(s); }
+inline base::JSONPtr ToJSON(std::string const & s) { return base::NewJSONString(s); }
 }  // namespace std
 
 namespace strings
 {
 void FromJSON(json_t * root, UniString & result);
-my::JSONPtr ToJSON(UniString const & s);
+base::JSONPtr ToJSON(UniString const & s);
 }  // namespace strings

3party/osrm/osrm-backend/mapsme/converter.cpp

@@ -260,7 +260,7 @@ void GenerateRoutingIndex(const std::string & fPath)
     routingCont.Finish();
   }
 
-  MY_SCOPE_GUARD(testFileGuard, bind(&my::DeleteFileX, cref(path)));
+  MY_SCOPE_GUARD(testFileGuard, bind(&base::DeleteFileX, cref(path)));
 
   FilesMappingContainer container;
   container.Open(path);

3party/sdf_image/sdf_image.cpp

@@ -142,7 +142,7 @@ void SdfImage::Distquant()
 {
   for_each(m_data.begin(), m_data.end(), [](float & node)
   {
-    node = my::clamp(0.5f + node * 0.0325f, 0.0f, 1.0f);
+    node = base::clamp(0.5f + node * 0.0325f, 0.0f, 1.0f);
   });
 }
 
@@ -266,7 +266,7 @@ float SdfImage::DistaA3(int c, int xc, int yc, int xi, int yi) const
   ASSERT_GREATER_OR_EQUAL(closest, 0, ());
   ASSERT_LESS(closest, m_data.size(), ());
 
-  float a = my::clamp(m_data[closest], 0.0f, 1.0f); // Grayscale value at the edge pixel
+  float a = base::clamp(m_data[closest], 0.0f, 1.0f); // Grayscale value at the edge pixel
 
   if(a == 0.0)
     return 1000000.0; // Not an object pixel, return "very far" ("don't know yet")

android/UnitTests/jni/mock.cpp

@@ -12,7 +12,7 @@
 
 #include <string>
 
-using namespace my;
+using namespace base;
 
 // @todo(vbykoianko) Probably it's worth thinking about output of the function to make the result of
 // the tests more readable.

android/jni/com/mapswithme/core/jni_helper.cpp

@@ -222,14 +222,14 @@ bool HandleJavaException(JNIEnv * env)
      jni::ScopedLocalRef<jthrowable> const e(env, env->ExceptionOccurred());
      env->ExceptionDescribe();
      env->ExceptionClear();
-     my::LogLevel level = GetLogLevelForException(env, e.get());
+     base::LogLevel level = GetLogLevelForException(env, e.get());
      LOG(level, (ToNativeString(env, e.get())));
      return true;
    }
    return false;
 }
 
-my::LogLevel GetLogLevelForException(JNIEnv * env, const jthrowable & e)
+base::LogLevel GetLogLevelForException(JNIEnv * env, const jthrowable & e)
 {
   static jclass const errorClass = jni::GetGlobalClassRef(env, "java/lang/Error");
   ASSERT(errorClass, (jni::DescribeException()));

android/jni/com/mapswithme/core/jni_helper.hpp

@@ -57,7 +57,7 @@ char const * GetStringClassName();
 
 std::string DescribeException();
 bool HandleJavaException(JNIEnv * env);
-my::LogLevel GetLogLevelForException(JNIEnv * env, const jthrowable & e);
+base::LogLevel GetLogLevelForException(JNIEnv * env, const jthrowable & e);
 
 std::shared_ptr<jobject> make_global_ref(jobject obj);
 using TScopedLocalRef = ScopedLocalRef<jobject>;

android/jni/com/mapswithme/core/logging.cpp

@@ -18,7 +18,7 @@ extern crashlytics_context_t * g_crashlytics;
 namespace jni
 {
 
-using namespace my;
+using namespace base;
 
 void AndroidMessage(LogLevel level, SrcPoint const & src, std::string const & s)
 {

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

@@ -114,7 +114,7 @@ void Framework::OnLocationUpdated(location::GpsInfo const & info)
 
 void Framework::OnCompassUpdated(location::CompassInfo const & info, bool forceRedraw)
 {
-  static double const COMPASS_THRESHOLD = my::DegToRad(1.0);
+  static double const COMPASS_THRESHOLD = base::DegToRad(1.0);
 
   /// @todo Do not emit compass bearing too often.
   /// Need to make more experiments in future.

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

@@ -92,7 +92,7 @@ Java_com_mapswithme_maps_downloader_MapManager_nativeGetRoot(JNIEnv * env, jclas
 JNIEXPORT jboolean JNICALL
 Java_com_mapswithme_maps_downloader_MapManager_nativeMoveFile(JNIEnv * env, jclass clazz, jstring oldFile, jstring newFile)
 {
-  return my::RenameFileX(jni::ToNativeString(env, oldFile), jni::ToNativeString(env, newFile));
+  return base::RenameFileX(jni::ToNativeString(env, oldFile), jni::ToNativeString(env, newFile));
 }
 
 // static boolean nativeHasSpaceForMigration();

android/jni/com/mapswithme/maps/editor/OsmOAuth.cpp

@@ -145,7 +145,7 @@ Java_com_mapswithme_maps_editor_OsmOAuth_nativeUpdateOsmUserStats(JNIEnv * env,
     JNIEnv * env = jni::GetEnv();
     env->CallStaticVoidMethod(osmAuthClazz, listenerId,
                               env->NewObject(statsClazz, statsCtor, count, rank, jni::ToJavaString(env, levelUp),
-                                             my::TimeTToSecondsSinceEpoch(userStats.GetLastUpdate())));
+                                             base::TimeTToSecondsSinceEpoch(userStats.GetLastUpdate())));
   });
 }
 } // extern "C"

android/jni/com/mapswithme/opengl/android_gl_utils.cpp

@@ -73,7 +73,7 @@ std::string GetEglError(EGLint error)
 
 }  // namespace
 
-void CheckEGL(my::SrcPoint const & src)
+void CheckEGL(base::SrcPoint const & src)
 {
   EGLint error = eglGetError();
   while (error != EGL_SUCCESS)