trace.hpp

Go to the documentation of this file.

#pragma once
#include "debug.hpp"

namespace xtd {
  namespace diagnostics {
    class core_export_ trace static_ {
    public:
      
      using listener_collection = xtd::diagnostics::trace_listener_collection;
      
      
      static bool auto_flush() noexcept;
      static void auto_flush(bool auto_flush) noexcept;
      
      static uint32 indent_level() noexcept;
      static void indent_level(uint32 indent_level) noexcept;
      
      static uint32 indent_size() noexcept;
      static void indent_size(uint32 indent_size) noexcept;
      
      static listener_collection& listeners() noexcept;
      static void listeners(const listener_collection& listeners) noexcept;
      
      static bool use_global_lock() noexcept;
      static void use_global_lock(bool use_global_lock) noexcept;
      
      
      static void cassert(bool condition, const xtd::diagnostics::stack_frame& stack_frame = xtd::diagnostics::stack_frame::current());
      static void cassert(bool condition, const xtd::string& message, const xtd::diagnostics::stack_frame& stack_frame = xtd::diagnostics::stack_frame::current());
      static void cassert(bool condition, const xtd::string& message, const xtd::string& detail_message, const xtd::diagnostics::stack_frame& stack_frame = xtd::diagnostics::stack_frame::current());
      
      static void fail(const xtd::string& message) {
        #if defined(TRACE)
        fail__(message);
        #endif
      }

      static void fail(const xtd::string& message, const xtd::string& detail_message) {
        #if defined(TRACE)
        fail__(message, detail_message);
        #endif
      }
      
      static void flush() {
        #if defined(TRACE)
        flush_();
        #endif
      }
      
      static void indent() noexcept;
      
      static void print(const xtd::string& message) {
        #if !defined(NDEBUG) || defined(DEBUG) || defined(TRACE)
        write_line_(message);
        #endif
      }

      template<class ...args_t>
      static void print(const xtd::string& format, args_t&& ... args) {
        #if !defined(NDEBUG) || defined(DEBUG) || defined(TRACE)
        write_line_(xtd::string::format(format, args...));
        #endif
      }

      template<class ...args_t>
      static void print(const char* format, args_t&& ... args) {
        #if !defined(NDEBUG) || defined(DEBUG) || defined(TRACE)
        write_line_(xtd::string::format(format, args...));
        #endif
      }
      
      static void trace_error(const xtd::string& message) {
        #if !defined(NDEBUG) || defined(DEBUG) || defined(TRACE)
        trace_event_(trace_event_type::error, message);
        #endif
      }

      template<class ...objects>
      static void trace_error(const xtd::string& message, const objects& ... args) {
        #if !defined(NDEBUG) || defined(DEBUG) || defined(TRACE)
        trace_event_(trace_event_type::error, message, args...);
        #endif
      }
      
      static void trace_information(const xtd::string& message) {
        #if !defined(NDEBUG) || defined(DEBUG) || defined(TRACE)
        trace_event_(trace_event_type::information, message);
        #endif
      }

      template<class ...objects>
      static void trace_information(const xtd::string& message, const objects& ... args) {
        #if !defined(NDEBUG) || defined(DEBUG) || defined(TRACE)
        trace_event_(trace_event_type::information, xtd::string::format(message, args...));
        #endif
      }
      
      static void trace_warning(const xtd::string& message) {
        #if !defined(NDEBUG) || defined(DEBUG) || defined(TRACE)
        trace_event_(trace_event_type::warning, message);
        #endif
      }

      template<class ...objects>
      static void trace_warning(const xtd::string& message, const objects& ... args) {
        #if !defined(NDEBUG) || defined(DEBUG) || defined(TRACE)
        trace_event_(trace_event_type::warning, xtd::string::format(message, args...));
        #endif
      }
      
      static void unindent() noexcept;
      
      static void write(const xtd::string& message) {
        #if defined(TRACE)
        write_(message);
        #endif
      }
      
      template<class object_t>
      static void write(const object_t& message) {
        #if defined(TRACE)
        write_(xtd::string::format("{}", message));
        #endif
      }

      template<class object_t>
      static void write(const object_t& message, const xtd::string& category) {
        #if defined(TRACE)
        write_(xtd::string::format("{}", message), category);
        #endif
      }

      template<class ...args_t>
      static void write(const xtd::string& format, args_t&& ... args) {
        #if defined(TRACE)
        write_(string::format(format, args...));
        #endif
      }

      template<class ...args_t>
      static void write(const char* format, args_t&& ... args) {
        #if defined(TRACE)
        write_(string::format(format, args...));
        #endif
      }
      
      static void write_if(bool condition, const xtd::string& message) {
        #if defined(TRACE)
        if (condition) write_(message);
        #endif
      }

      template<class object_t>
      static void write_if(bool condition, const object_t& message) {
        #if defined(TRACE)
        if (condition) write_(xtd::string::format("{}", message));
        #endif
      }

      template<class object_t>
      static void write_if(bool condition, const object_t& message, const xtd::string& category) {
        #if defined(TRACE)
        if (condition) write_(xtd::string::format("{}", message), category);
        #endif
      }
      
      static void write_line() {
        #if defined(TRACE)
        write_line_("");
        #endif
      }

      static void write_line(const xtd::string& message) {
        #if defined(TRACE)
        write_line_(message);
        #endif
      }

      template<class object_t>
      static void write_line(const object_t& message) {
        #if defined(TRACE)
        write_line_(xtd::string::format("{}", message));
        #endif
      }

      template<class object_t>
      static void write_line(const object_t& message, const xtd::string& category) {
        #if defined(TRACE)
        write_line_(xtd::string::format("{}", message), category);
        #endif
      }

      template<class ...args_t>
      static void write_line(const xtd::string& format, args_t&& ... args) {
        #if defined(TRACE)
        write_line_(xtd::string::format(format, args...));
        #endif
      }

      template<class ...args_t>
      static void write_line(const char* format, args_t&& ... args) {
        #if defined(TRACE)
        write_line_(xtd::string::format(format, args...));
        #endif
      }
      
      static void write_line_if(bool condition, const xtd::string& message) {
        #if defined(TRACE)
        if (condition) write_line_(message);
        #endif
      }

      template<class object_t>
      static void write_line_if(bool condition, const object_t& message) {
        #if defined(TRACE)
        if (condition) write_line_(xtd::string::format("{}", message));
        #endif
      }

      template<class object_t>
      static void write_line_if(bool condition, const object_t& message, const xtd::string& category) {
        #if defined(TRACE)
        if (condition) write_line_(xtd::string::format("{}", message), category);
        #endif
      }

      
      static inline bool __should_aborted__(const xtd::diagnostics::stack_frame& stack_frame, bool condition) {return __should_aborted__(stack_frame, condition, xtd::string::empty_string);}
      static inline bool __should_aborted__(const xtd::diagnostics::stack_frame& stack_frame, bool condition, const xtd::string& message) {return __should_aborted__(stack_frame, condition, message, xtd::string::empty_string);}
      static inline bool __should_aborted__(const xtd::diagnostics::stack_frame& stack_frame, bool condition, const xtd::string& message, const xtd::string& detail_message) {
        #if defined(TRACE)
        auto result = xtd::diagnostics::debug::assert_dialog(condition, message, detail_message, stack_frame);
        if (result == xtd::diagnostics::assert_dialog_result::abort) xtd::environment::exit(EXIT_FAILURE);
        if (result == xtd::diagnostics::assert_dialog_result::retry) return true;
        #endif
        return false;
      }
      
      
      [[deprecated("Replaced by xtd::diagnostics::default_trace_listener::assert_ui_enabled - Will be removed in version 0.4.0.")]]
      static bool show_assert_dialog() noexcept;
      [[deprecated("Replaced by xtd::diagnostics::default_trace_listener::assert_ui_enabled - Will be removed in version 0.4.0.")]]
      static void show_assert_dialog(bool show_assert_dialog) noexcept;
      
    private:
      static void fail__(const xtd::string& message);
      static void fail__(const xtd::string& message, const xtd::string& detail_message);
      static void flush_();
      static void trace_event_(trace_event_type trace_event_type, const xtd::string& message);
      static void write_(const xtd::string& message);
      static void write_(const xtd::string& message, const xtd::string& category);
      static void write_line_(const xtd::string& message);
      static void write_line_(const xtd::string& message, const xtd::string& category);
      
      inline static bool auto_flush_ = false;
      inline static uint32 indent_level_ = 0;
      inline static uint32 indent_size_ = 4;
      static listener_collection& listeners_;
      inline static bool use_global_lock_ = true;
      static xtd::string source_name_;
    };
  }
}