Update registry.h

include/spdlog/details/registry.h

@@ -31,7 +31,7 @@ public:
     registry_t<Mutex>(const registry_t<Mutex> &) = delete;
     registry_t<Mutex> &operator=(const registry_t<Mutex> &) = delete;
 
-    void register_logger(std::shared_ptr<logger> logger)
+    void register_logger(shared_ptr<logger> logger)
     {
         std::lock_guard<Mutex> lock(_mutex);
         auto logger_name = logger->name();
@@ -39,7 +39,7 @@ public:
         _loggers[logger_name] = logger;
     }
 
-    std::shared_ptr<logger> get(const std::string &logger_name)
+    shared_ptr<logger> get(const string &logger_name)
     {
         std::lock_guard<Mutex> lock(_mutex);
         auto found = _loggers.find(logger_name);
@@ -47,19 +47,19 @@ public:
     }
 
     template<class It>
-    std::shared_ptr<logger> create(const std::string &logger_name, const It &sinks_begin, const It &sinks_end)
+    shared_ptr<logger> create(const string &logger_name, const It &sinks_begin, const It &sinks_end)
     {
         std::lock_guard<Mutex> lock(_mutex);
         throw_if_exists(logger_name);
-        std::shared_ptr<logger> new_logger;
+        shared_ptr<logger> new_logger;
         if (_async_mode)
         {
-            new_logger = std::make_shared<async_logger>(logger_name, sinks_begin, sinks_end, _async_q_size, _overflow_policy,
+            new_logger = spdlog::make_shared<async_logger>(logger_name, sinks_begin, sinks_end, _async_q_size, _overflow_policy,
                 _worker_warmup_cb, _flush_interval_ms, _worker_teardown_cb);
         }
         else
         {
-            new_logger = std::make_shared<logger>(logger_name, sinks_begin, sinks_end);
+            new_logger = spdlog::make_shared<logger>(logger_name, sinks_begin, sinks_end);
         }
 
         if (_formatter)
@@ -81,14 +81,14 @@ public:
     }
 
     template<class It>
-    std::shared_ptr<async_logger> create_async(const std::string &logger_name, size_t queue_size,
+    shared_ptr<async_logger> create_async(const string &logger_name, size_t queue_size,
         const async_overflow_policy overflow_policy, const std::function<void()> &worker_warmup_cb,
         const std::chrono::milliseconds &flush_interval_ms, const std::function<void()> &worker_teardown_cb, const It &sinks_begin,
         const It &sinks_end)
     {
         std::lock_guard<Mutex> lock(_mutex);
         throw_if_exists(logger_name);
-        auto new_logger = std::make_shared<async_logger>(
+        auto new_logger = spdlog::make_shared<async_logger>(
             logger_name, sinks_begin, sinks_end, queue_size, overflow_policy, worker_warmup_cb, flush_interval_ms, worker_teardown_cb);
 
         if (_formatter)
@@ -109,7 +109,7 @@ public:
         return new_logger;
     }
 
-    void apply_all(std::function<void(std::shared_ptr<logger>)> fun)
+    void apply_all(std::function<void(shared_ptr<logger>)> fun)
     {
         std::lock_guard<Mutex> lock(_mutex);
         for (auto &l : _loggers)
@@ -118,7 +118,7 @@ public:
         }
     }
 
-    void drop(const std::string &logger_name)
+    void drop(const string &logger_name)
     {
         std::lock_guard<Mutex> lock(_mutex);
         _loggers.erase(logger_name);
@@ -130,17 +130,17 @@ public:
         _loggers.clear();
     }
 
-    std::shared_ptr<logger> create(const std::string &logger_name, sinks_init_list sinks)
+    shared_ptr<logger> create(const string &logger_name, sinks_init_list sinks)
     {
         return create(logger_name, sinks.begin(), sinks.end());
     }
 
-    std::shared_ptr<logger> create(const std::string &logger_name, sink_ptr sink)
+    shared_ptr<logger> create(const string &logger_name, sink_ptr sink)
     {
         return create(logger_name, {sink});
     }
 
-    std::shared_ptr<async_logger> create_async(const std::string &logger_name, size_t queue_size,
+    shared_ptr<async_logger> create_async(const string &logger_name, size_t queue_size,
         const async_overflow_policy overflow_policy, const std::function<void()> &worker_warmup_cb,
         const std::chrono::milliseconds &flush_interval_ms, const std::function<void()> &worker_teardown_cb, sinks_init_list sinks)
     {
@@ -148,7 +148,7 @@ public:
             logger_name, queue_size, overflow_policy, worker_warmup_cb, flush_interval_ms, worker_teardown_cb, sinks.begin(), sinks.end());
     }
 
-    std::shared_ptr<async_logger> create_async(const std::string &logger_name, size_t queue_size,
+    shared_ptr<async_logger> create_async(const string &logger_name, size_t queue_size,
         const async_overflow_policy overflow_policy, const std::function<void()> &worker_warmup_cb,
         const std::chrono::milliseconds &flush_interval_ms, const std::function<void()> &worker_teardown_cb, sink_ptr sink)
     {
@@ -165,10 +165,10 @@ public:
         }
     }
 
-    void set_pattern(const std::string &pattern)
+    void set_pattern(const string &pattern)
     {
         std::lock_guard<Mutex> lock(_mutex);
-        _formatter = std::make_shared<pattern_formatter>(pattern);
+        _formatter = spdlog::make_shared<pattern_formatter>(pattern);
         for (auto &l : _loggers)
         {
             l.second->set_formatter(_formatter);
@@ -231,7 +231,7 @@ public:
 private:
     registry_t<Mutex>() = default;
 
-    void throw_if_exists(const std::string &logger_name)
+    void throw_if_exists(const string &logger_name)
     {
         if (_loggers.find(logger_name) != _loggers.end())
         {
@@ -240,7 +240,7 @@ private:
     }
 
     Mutex _mutex;
-    std::unordered_map<std::string, std::shared_ptr<logger>> _loggers;
+    unordered_map<string, shared_ptr<logger>> _loggers;
     formatter_ptr _formatter;
     level::level_enum _level = level::info;
     level::level_enum _flush_level = level::off;