trace_listener.h

Go to the documentation of this file.

 
#pragma once
#include <memory>
#include <stdexcept>
#include "../abstract.h"
#include "../string.h"
#include "trace_event_cache.h"
#include "trace_event_type.h"
#include "trace_options.h"
 
namespace xtd {
  namespace diagnostics {
    class core_export_ trace_listener abstract_ {
    public:
      
      trace_listener() = default;
      
      trace_listener(const trace_listener& tl) = delete;
      trace_listener& operator =(const trace_listener& tl) = delete;
      ~trace_listener();
      
      explicit trace_listener(const xtd::string& name);
      
      
      uint32 indent_level() const noexcept;
      
      void indent_level(uint32 indent_level) noexcept;
      
      uint32 indent_size() const noexcept;
      
      void indent_size(uint32 indent_size) noexcept;
      
      virtual bool is_thread_safe() const noexcept;
      
      const xtd::string& name() const noexcept;
      
      void name(const xtd::string& name) noexcept;
      
      trace_options trace_output_options() const noexcept;
      
      void trace_output_options(trace_options trace_output_options) noexcept;
      
      
      virtual void close();
      
      virtual void fail(const xtd::string& message) {
        #if !defined(NDEBUG) || defined(DEBUG) || defined(TRACE)
        write_line(xtd::string::format("Fail: {}", message));
        #endif
      }
      
      virtual void fail(const xtd::string& message, const xtd::string& detail_message) {
        #if !defined(NDEBUG) || defined(DEBUG) || defined(TRACE)
        write_line(xtd::string::format("Fail: {} {}", message, detail_message));
        #endif
      }
      
      virtual void flush() {}
      
      template<typename object>
      void trace_data(const xtd::diagnostics::trace_event_cache& event_cache, const xtd::string& source, const xtd::diagnostics::trace_event_type& event_type, int32 id, const object& data) {
        #if !defined(NDEBUG) || defined(DEBUG) || defined(TRACE)
        write_line(xtd::string::format("{} {}: {} : {}", source, event_type, id, data));
        write_event_cache(event_cache);
        #endif
      }
      
      template<typename object>
      void trace_data(const xtd::diagnostics::trace_event_cache& event_cache, const xtd::string& source, const xtd::diagnostics::trace_event_type& event_type, int32 id, const std::vector<object>& data) {
        #if !defined(NDEBUG) || defined(DEBUG) || defined(TRACE)
        write_line(xtd::string::format("{} {}: {} : {}", source, event_type, id, xtd::string::join(", ", data)));
        write_event_cache(event_cache);
        #endif
      }
      
      template<typename ...objects>
      void trace_data(const xtd::diagnostics::trace_event_cache& event_cache, const xtd::string& source, const xtd::diagnostics::trace_event_type& event_type, int32 id, const objects& ... data) {
        #if !defined(NDEBUG) || defined(DEBUG) || defined(TRACE)
        write_line(xtd::string::format("{} {}: {} : {}", source, event_type, id, xtd::string::join(", ", {data...})));
        write_event_cache(event_cache);
        #endif
      }
      
      virtual void trace_event(const xtd::diagnostics::trace_event_cache& event_cache, const xtd::string& source, const xtd::diagnostics::trace_event_type& event_type, int32 id) {
        #if !defined(NDEBUG) || defined(DEBUG) || defined(TRACE)
        write_line(xtd::string::format("{} {}: {}", source, event_type, id));
        write_event_cache(event_cache);
        #endif
      }
      
      virtual void trace_event(const xtd::diagnostics::trace_event_cache& event_cache, const xtd::string& source, const xtd::diagnostics::trace_event_type& event_type, int32 id, const xtd::string& message) {
        #if !defined(NDEBUG) || defined(DEBUG) || defined(TRACE)
        write_line(xtd::string::format("{} {}: {} : {}", source, event_type, id, message));
        write_event_cache(event_cache);
        #endif
      }
      
      template<typename ...objects>
      void trace_event(const xtd::diagnostics::trace_event_cache& event_cache, const xtd::string& source, const xtd::diagnostics::trace_event_type& event_type, int32 id, const xtd::string& format, const objects& ... args) {
        #if !defined(NDEBUG) || defined(DEBUG) || defined(TRACE)
        write_line(xtd::string::format("{} {}: {} : {}", source, event_type, id, xtd::string::format(format, args...)));
        write_event_cache(event_cache);
        #endif
      }
      
      template<typename activity_id_type>
      void trace_transfer(const xtd::diagnostics::trace_event_cache& event_cache, const xtd::string& source, int32 id, const xtd::string& message, const activity_id_type& related_activity_id) {
        #if !defined(NDEBUG) || defined(DEBUG) || defined(TRACE)
        write_line(xtd::string::format("{} transfer: {} : {}, related_activity_id={}", source, id, message, related_activity_id));
        write_event_cache(event_cache);
        #endif
      }
      
      template <typename object>
      void write(const object& o) {
        #if !defined(NDEBUG) || defined(DEBUG) || defined(TRACE)
        write(xtd::string::format("{}", o));
        #endif
      }
      
      template <typename object>
      void write(const object& o, const xtd::string& category) {
        #if !defined(NDEBUG) || defined(DEBUG) || defined(TRACE)
        write(xtd::string::format("{} : {}", o, category));
        #endif
      }
      
      virtual void write(const xtd::string& message) = 0;
      
      template <typename object>
      void write_line(const object& o) {
        #if !defined(NDEBUG) || defined(DEBUG) || defined(TRACE)
        write_line(xtd::string::format("{}", o));
        #endif
      }
      
      template <typename object>
      void write_line(const object& o, const xtd::string& category) {
        #if !defined(NDEBUG) || defined(DEBUG) || defined(TRACE)
        write_line(xtd::string::format("{} : {}", o, category));
        #endif
      }
      
      virtual void write_line(const xtd::string& message) = 0;
      
      template<typename object>
      trace_listener& operator <<(object&& message) {
        #if !defined(NDEBUG) || defined(DEBUG) || defined(TRACE)
        write_line(message);
        #endif
        return *this;
      }
      
    protected:
      
      bool need_indent() const noexcept;
      void need_indent(bool need_indent) noexcept;
      
      void thread_safe(bool thread_safe) noexcept;
      
      
      virtual void write_indent() {
        #if !defined(NDEBUG) || defined(DEBUG) || defined(TRACE)
        need_indent_ = false;
        for (uint32 i = 0; i < indent_level_; ++i)
          write(xtd::string(indent_size_, ' '));
        #endif
      }
      
    private:
      void write_event_cache(const trace_event_cache& event_cache);
      
      uint32 indent_level_ = 0;
      uint32 indent_size_ = 4;
      bool is_thread_safe_ = false;
      xtd::string name_;
      bool need_indent_ = true;
      trace_options trace_output_options_ = trace_options::none;
    };
  }
}