git.sesse.net Git - casparcg/blob - core/monitor/monitor.h

   1 #pragma once
   2
   3 #include <common/memory/safe_ptr.h>
   4 #include <common/utility/assert.h>
   5
   6 #include <boost/variant.hpp>
   7 #include <boost/chrono/duration.hpp>
   8
   9 #include <cstdint>
  10 #include <string>
  11 #include <vector>
  12
  13 #include <agents.h>
  14
  15 namespace caspar { namespace core { namespace monitor {
  16
  17 typedef boost::variant<bool,
  18                                            std::int32_t,
  19                                            std::int64_t,
  20                                            float,
  21                                            double,
  22                                            std::string,
  23                                            std::wstring,
  24                                            std::vector<std::int8_t>> data_t;
  25
  26 class message
  27 {
  28 public:
  29
  30         message(std::string path, std::vector<data_t> data = std::vector<data_t>())
  31                 : path_(std::move(path))
  32                 , data_ptr_(std::make_shared<std::vector<data_t>>(std::move(data)))
  33         {
  34                 CASPAR_ASSERT(path.empty() || path[0] == '/');
  35         }
  36
  37         message(std::string path, safe_ptr<std::vector<data_t>> data_ptr)
  38                 : path_(std::move(path))
  39                 , data_ptr_(std::move(data_ptr))
  40         {
  41                 CASPAR_ASSERT(path.empty() || path[0] == '/');
  42         }
  43
  44         const std::string& path() const
  45         {
  46                 return path_;
  47         }
  48
  49         const std::vector<data_t>& data() const
  50         {
  51                 return *data_ptr_;
  52         }
  53
  54         message propagate(const std::string& path) const
  55         {
  56                 return message(path + path_, data_ptr_);
  57         }
  58
  59         template<typename T>
  60         message& operator%(T&& data)
  61         {
  62                 data_ptr_->push_back(std::forward<T>(data));
  63                 return *this;
  64         }
  65
  66 private:
  67         std::string                                             path_;
  68         safe_ptr<std::vector<data_t>>   data_ptr_;
  69 };
  70
  71 class subject : public Concurrency::transformer<monitor::message, monitor::message>
  72 {
  73 public:
  74         subject(std::string path = "")
  75                 : Concurrency::transformer<monitor::message, monitor::message>([=](const message& msg)
  76                 {
  77                         return msg.propagate(path);
  78                 })
  79         {
  80                 CASPAR_ASSERT(path.empty() || path[0] == '/');
  81         }
  82
  83         template<typename T>
  84         subject& operator<<(T&& msg)
  85         {
  86                 Concurrency::send(*this, std::forward<T>(msg));
  87                 return *this;
  88         }
  89 };
  90
  91 typedef Concurrency::ISource<monitor::message> source;
  92
  93
  94 }}}