ilisten.h

Go to the documentation of this file.

/*
 * Copyright 2021 Ingemar Hedvall
 * SPDX-License-Identifier: MIT
 */

#pragma once
 
#include <map>
#include <memory>
#include <sstream>
#include <string>
#include <vector>
#include <atomic>
 
namespace util::log {
 
class ListenStream;

enum class TypeOfListen {
  ListenProxyType = 0, 
  ListenServerType, 
  ListenConsoleType, 
};

class IListen {
 public:
  virtual ~IListen() = default;  

  [[nodiscard]] const std::string &Name() const { return name_; }

  void Name(const std::string &name) { name_ = name; }

  [[nodiscard]] const std::string &Description() const { return description_; }

  void Description(const std::string &description) {
    description_ = description;
  }

  [[nodiscard]] const std::string &PreText() const { return pre_text_; }

  void PreText(const std::string &pre_text) { pre_text_ = pre_text; }

  [[nodiscard]] const std::string &HostName() const { return host_name_; }

  void HostName(const std::string &host_name) { host_name_ = host_name; }

  [[nodiscard]] uint16_t Port() const { return port_; }

  void Port(uint16_t port) { port_ = port; }

  void SetLogLevelText(uint64_t level, const std::string &menu_text);

  [[nodiscard]] const std::map<uint64_t, std::string> &LogLevelList() const;

  void ListenString(const std::string &text);
 
  ListenStream ListenOut();  

  void ListenText(const char *format_text, ...);

  void ListenTextEx(uint64_t ns1970, const std::string &pre_text,
                    const char *format_text, ...);

  virtual void ListenTransmit(uint64_t ns1970, const std::string &pre_text,
                              const std::vector<uint8_t> &buffer, void *hint);

  virtual void ListenReceive(uint64_t ns1970, const std::string &pre_text,
                             const std::vector<uint8_t> &buffer, void *hint);
 
  virtual void SetActive(
      bool active);  

  [[nodiscard]] virtual bool IsActive() const = 0;
 
  virtual void SetLogLevel(size_t log_level);  

  [[nodiscard]] virtual size_t LogLevel() = 0;

  virtual bool Start();

  virtual bool Stop();

  [[nodiscard]] virtual size_t NofConnections() const;

  uint64_t GetNumberOfMessages() const { return number_of_messages_; }

  void ResetNumberOfMessages() { number_of_messages_ = 0; }
 
 protected:
  std::string share_name_;   
  std::string name_;         
  std::string description_;  
  std::string pre_text_;     
  std::string host_name_ = "127.0.0.1";             
  uint16_t port_ = 0;                               
  std::map<uint64_t, std::string> log_level_list_;  
 
 
  IListen() = default;                              

  virtual void AddMessage(uint64_t nano_sec_1970, const std::string &pre_text,
                          const std::string &text) = 0;

  static std::string ParseHex(const std::vector<uint8_t> &buffer);

  void IncrementNumberOfMessages() { ++number_of_messages_; }
 
 private:
  std::atomic<uint64_t> number_of_messages_ = 0;
};

class ListenStream final : public std::ostringstream {
 public:
  ListenStream() = delete;
 
  explicit ListenStream(IListen &listen) : listen_(listen) {}  
 
  ~ListenStream() override {                                   
    if (listen_.IsActive()) {
      listen_.ListenString(str());
    }
  }
 
 private:
  IListen &listen_;  
};
}  // namespace util::log