log.hpp

#pragma once
 
 
#include "module.hpp"
#include "attribute_map.hpp"
 
namespace Cvb
{
  CVB_BEGIN_INLINE_NS
 
  namespace Telemetry
  {

    class Log : public AttributeMap
    {
    public:

      static Log Create()
      {
        return {};
      }


      static Log Create(LogLevel logLevel)
      {
        return Log{logLevel};
      }
 
      Log(const Log &)            = delete;
      Log &operator=(const Log &) = delete;
      Log(Log &&other) noexcept
          : AttributeMap(std::move(other))
          , message_(std::move(other.message_))
          , logLevel_(std::move(other.logLevel_))
      {
      }
 
      Log &operator=(Log &&other) noexcept
      {
        if (this != &other)
        {
          AttributeMap::operator=(std::move(other));
          message_    = std::move(other.message_);
          logLevel_   = std::move(other.logLevel_);
        }
        return *this;
      }
 
      ~Log()
      {
        if (!handle_)
          return;
 
        Flush();
        CExports::CVTSendLog(handle_, message_.c_str());
        handle_ = nullptr;
      }


      explicit operator bool() const noexcept
      {
        return handle_ != nullptr;
      }
 
      const std::string& Message() const noexcept
      {
        return message_;
      }
 
 
      LogLevel Loglevel() const noexcept
      {
        return logLevel_;
      }
 
      template <class...>
      using void_t = void;
 
      template <typename T, typename = void>
      struct is_ostreamable : std::false_type
      {
      };
 
      template <typename T>
      struct is_ostreamable<T, void_t<decltype(std::declval<std::ostream &>() << std::declval<T>())>> : std::true_type
      {
      };

      template <typename T, typename = typename std::enable_if<is_ostreamable<T>::value>::type>
      Log &operator<<(const T &value)
      {
        std::ostringstream oss;
        oss << value;  // Convert the value to a string if it can be output to a stream
        message_ += oss.str();
        return *this;
      }
 
      Log &operator<<(const std::pair<std::string, Telemetry::Attribute> &kv)
      {
        (*this)(kv.first, kv.second);
        return *this;
      }
 
    private:
      explicit Log(LogLevel logLevel)
          : AttributeMap()
          , logLevel_(logLevel)
      {
        auto &module = Module::Get();
        if (!module.WouldLog())
          return;
        CExports::CVTLOG handle = nullptr;
        CExports::CVTCreateLog(module.Handle(), static_cast<CExports::CVTLogLevel>(logLevel), handle);
        handle_ = handle;
      }
 
      Log() noexcept = default;
 
      LogLevel logLevel_ = LogLevel::LevelDebug;
      std::string message_;
    };
  }  // namespace Telemetry
 
  CVB_END_INLINE_NS
}  // namespace Cvb