trace_listener.h

Go to the documentation of this file.

#pragma once
#include <memory>
#include <stdexcept>
#include "../abstract.h"
#include "../ustring.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::ustring& name);
      
      
      unsigned int indent_level() const;
      
      void indent_level(unsigned int indent_level);
      
      unsigned int indent_size() const;
      
      void indent_size(unsigned int indent_size);
      
      virtual bool is_thread_safe() const;
      
      const xtd::ustring& name() const;
      
      void name(const xtd::ustring& name);
      
      const trace_options& trace_output_options() const;
      
      void trace_output_options(const trace_options& trace_output_options);
      
      
      virtual void close();
      
      virtual void fail(const xtd::ustring& message) {
        #if !defined(NDEBUG) || defined(DEBUG) || defined(TRACE)
        write_line(xtd::ustring::format("Fail: {}", message));
        #endif
      }
      
      virtual void fail(const xtd::ustring& message, const xtd::ustring& detail_message) {
        #if !defined(NDEBUG) || defined(DEBUG) || defined(TRACE)
        write_line(xtd::ustring::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::ustring& source, const xtd::diagnostics::trace_event_type& event_type, int id, const object& data) {
        #if !defined(NDEBUG) || defined(DEBUG) || defined(TRACE)
        write_line(xtd::ustring::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::ustring& source, const xtd::diagnostics::trace_event_type& event_type, int id, const std::vector<object>& data) {
        #if !defined(NDEBUG) || defined(DEBUG) || defined(TRACE)
        write_line(xtd::ustring::format("{} {}: {} : {}", source, event_type, id, xtd::ustring::join(", ", data)));
        write_event_cache(event_cache);
        #endif
      }
      
      template<typename ...objects>
      void trace_data(const xtd::diagnostics::trace_event_cache& event_cache, const xtd::ustring& source, const xtd::diagnostics::trace_event_type& event_type, int id, const objects& ... data) {
        #if !defined(NDEBUG) || defined(DEBUG) || defined(TRACE)
        write_line(xtd::ustring::format("{} {}: {} : {}", source, event_type, id, xtd::ustring::join(", ", {data...})));
        write_event_cache(event_cache);
        #endif
      }
      
      virtual void trace_event(const xtd::diagnostics::trace_event_cache& event_cache, const xtd::ustring& source, const xtd::diagnostics::trace_event_type& event_type, int id) {
        #if !defined(NDEBUG) || defined(DEBUG) || defined(TRACE)
        write_line(xtd::ustring::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::ustring& source, const xtd::diagnostics::trace_event_type& event_type, int id, const xtd::ustring& message) {
        #if !defined(NDEBUG) || defined(DEBUG) || defined(TRACE)
        write_line(xtd::ustring::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::ustring& source, const xtd::diagnostics::trace_event_type& event_type, int id, const xtd::ustring& format, const objects& ... args) {
        #if !defined(NDEBUG) || defined(DEBUG) || defined(TRACE)
        write_line(xtd::ustring::format("{} {}: {} : {}", source, event_type, id, xtd::ustring::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::ustring& source, int id, const xtd::ustring& message, const activity_id_type& related_activity_id) {
        #if !defined(NDEBUG) || defined(DEBUG) || defined(TRACE)
        write_line(xtd::ustring::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::ustring::format("{}", o));
        #endif
      }
      
      template <typename object>
      void write(const object& o, const xtd::ustring& category) {
        #if !defined(NDEBUG) || defined(DEBUG) || defined(TRACE)
        write(xtd::ustring::format("{} : {}", o, category));
        #endif
      }
      
      virtual void write(const xtd::ustring& message) = 0;
      
      template <typename object>
      void write_line(const object& o) {
        #if !defined(NDEBUG) || defined(DEBUG) || defined(TRACE)
        write_line(xtd::ustring::format("{}", o));
        #endif
      }
      
      template <typename object>
      void write_line(const object& o, const xtd::ustring& category) {
        #if !defined(NDEBUG) || defined(DEBUG) || defined(TRACE)
        write_line(xtd::ustring::format("{} : {}", o, category));
        #endif
      }
      
      virtual void write_line(const xtd::ustring& 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;
      void need_indent(bool need_indent);
      
      void thread_safe(bool thread_safe);
      
      
      virtual void write_indent() {
        #if !defined(NDEBUG) || defined(DEBUG) || defined(TRACE)
        need_indent_ = false;
        for (unsigned int i = 0; i < indent_level_; ++i)
          write(xtd::ustring(indent_size_, ' '));
        #endif
      }
      
    private:
      void write_event_cache(const trace_event_cache& event_cache);
      
      unsigned int indent_level_ = 0;
      unsigned int indent_size_ = 4;
      bool is_thread_safe_ = false;
      xtd::ustring name_;
      bool need_indent_ = true;
      trace_options trace_output_options_ = trace_options::none;
    };
  }
}