Blame view

3rdparty/spdlog-1.9.2/release/include/spdlog/sinks/dist_sink.h 2.35 KB
3d2ab595   Hu Chunming   支持gb28181
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
  // Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
  // Distributed under the MIT License (http://opensource.org/licenses/MIT)
  
  #pragma once
  
  #include "base_sink.h"
  #include <spdlog/details/log_msg.h>
  #include <spdlog/details/null_mutex.h>
  #include <spdlog/pattern_formatter.h>
  
  #include <algorithm>
  #include <memory>
  #include <mutex>
  #include <vector>
  
  // Distribution sink (mux). Stores a vector of sinks which get called when log
  // is called
  
  namespace spdlog {
  namespace sinks {
  
  template<typename Mutex>
  class dist_sink : public base_sink<Mutex>
  {
  public:
      dist_sink() = default;
      explicit dist_sink(std::vector<std::shared_ptr<sink>> sinks)
          : sinks_(sinks)
      {}
  
      dist_sink(const dist_sink &) = delete;
      dist_sink &operator=(const dist_sink &) = delete;
  
      void add_sink(std::shared_ptr<sink> sink)
      {
          std::lock_guard<Mutex> lock(base_sink<Mutex>::mutex_);
          sinks_.push_back(sink);
      }
  
      void remove_sink(std::shared_ptr<sink> sink)
      {
          std::lock_guard<Mutex> lock(base_sink<Mutex>::mutex_);
          sinks_.erase(std::remove(sinks_.begin(), sinks_.end(), sink), sinks_.end());
      }
  
      void set_sinks(std::vector<std::shared_ptr<sink>> sinks)
      {
          std::lock_guard<Mutex> lock(base_sink<Mutex>::mutex_);
          sinks_ = std::move(sinks);
      }
  
      std::vector<std::shared_ptr<sink>> &sinks()
      {
          return sinks_;
      }
  
  protected:
      void sink_it_(const details::log_msg &msg) override
      {
          for (auto &sink : sinks_)
          {
              if (sink->should_log(msg.level))
              {
                  sink->log(msg);
              }
          }
      }
  
      void flush_() override
      {
          for (auto &sink : sinks_)
          {
              sink->flush();
          }
      }
  
      void set_pattern_(const std::string &pattern) override
      {
          set_formatter_(details::make_unique<spdlog::pattern_formatter>(pattern));
      }
  
      void set_formatter_(std::unique_ptr<spdlog::formatter> sink_formatter) override
      {
          base_sink<Mutex>::formatter_ = std::move(sink_formatter);
          for (auto &sink : sinks_)
          {
              sink->set_formatter(base_sink<Mutex>::formatter_->clone());
          }
      }
      std::vector<std::shared_ptr<sink>> sinks_;
  };
  
  using dist_sink_mt = dist_sink<std::mutex>;
  using dist_sink_st = dist_sink<details::null_mutex>;
  
  } // namespace sinks
  } // namespace spdlog