debug.h

Go to the documentation of this file.

#pragma once
#include <cstdint>
#include <cstdlib>
#include <mutex>
#include "../add_last_arg_to_command.h"
#include "../core_export.h"
#include "../environment.h"
#include "../static.h"
#include "../ustring.h"
#include "assert_dialog_result.h"
#include "debugger.h"
#include "stack_trace.h"
#include "trace_listener_collection.h"
 
namespace xtd {
  namespace diagnostics {
    class trace;
    class core_export_ debug static_ {
    public:
      using listener_collection = xtd::diagnostics::trace_listener_collection;
      
      static bool auto_flush();
      static void auto_flush(bool auto_flush);
 
      static uint32_t indent_level();
      static void indent_level(uint32_t indent_level);
      
      static uint32_t indent_size();
      static void indent_size(uint32_t indent_size);
      
      static listener_collection& listeners();
      static void listeners(const listener_collection& listeners);
      
      static bool show_assert_dialog();
      static void show_assert_dialog(bool show_assert_dialog);
 
      static bool use_global_lock();
      static void use_global_lock(bool use_global_lock);
 
      static void cassert(bool condition);
      static void cassert(bool condition, const xtd::ustring& message);
      static void cassert(bool condition, const xtd::ustring& message, const xtd::diagnostics::stack_frame& stack_frame);
      static void cassert(bool condition, const xtd::diagnostics::stack_frame& stack_frame);
 
      static void fail(const xtd::ustring& message) {
#if !defined(NDEBUG) || defined(DEBUG) || defined(TRACE)
        fail__(message);
#endif
      }
      static void fail(const xtd::ustring& message, const xtd::ustring& detail_message) {
#if !defined(NDEBUG) || defined(DEBUG) || defined(TRACE)
        fail__(message, detail_message);
#endif
      }
 
      static void flush() {
#if !defined(NDEBUG) || defined(DEBUG) || defined(TRACE)
        flush_();
#endif
      }
      
      static void indent();
      
      static void print(const xtd::ustring& message) {
#if !defined(NDEBUG) || defined(DEBUG) || defined(TRACE)
        write_line_(message);
#endif
      }
      template<typename ...args_t>
      static void print(const xtd::ustring& format, args_t&&... args) {
#if !defined(NDEBUG) || defined(DEBUG) || defined(TRACE)
        write_line_(xtd::ustring::format(format, args...));
#endif
      }
      template<typename ...args_t>
      static void print(const char* format, args_t&&... args) {
#if !defined(NDEBUG) || defined(DEBUG) || defined(TRACE)
        write_line_(xtd::ustring::format(format, args...));
#endif
      }
      
      static void trace_error(const xtd::ustring& message) {
#if !defined(NDEBUG) || defined(DEBUG) || defined(TRACE)
        trace_event_(trace_event_type::error, message);
#endif
      }
      template<typename ...objects_t>
      static void trace_error(const xtd::ustring& message, const objects_t& ... args) {
#if !defined(NDEBUG) || defined(DEBUG) || defined(TRACE)
        trace_event_(trace_event_type::error, xtd::ustring::format(message, args...));
#endif
      }
      
      static void trace_information(const xtd::ustring& message) {
#if !defined(NDEBUG) || defined(DEBUG) || defined(TRACE)
        trace_event_(trace_event_type::information, message);
#endif
      }
      template<typename ...objects_t>
      static void trace_information(const xtd::ustring& message, const objects_t& ... args) {
#if !defined(NDEBUG) || defined(DEBUG) || defined(TRACE)
        trace_event_(trace_event_type::information, xtd::ustring::format(message, args...));
#endif
      }
 
      static void trace_warning(const xtd::ustring& message) {
#if !defined(NDEBUG) || defined(DEBUG) || defined(TRACE)
        trace_event_(trace_event_type::warning, message);
#endif
      }
      template<typename ...objects_t>
      static void trace_warning(const xtd::ustring& message, const objects_t& ... args) {
#if !defined(NDEBUG) || defined(DEBUG) || defined(TRACE)
        trace_event_(trace_event_type::warning, xtd::ustring::format(message, args...));
#endif
      }
 
      static void unindent();
 
      static void write(const xtd::ustring& message) {
#if !defined(NDEBUG) || defined(DEBUG) || defined(TRACE)
        write_(message);
#endif
      }
      template<typename object_t>
      static void write(const object_t& message) {
#if !defined(NDEBUG) || defined(DEBUG) || defined(TRACE)
        write_(xtd::ustring::format("", message));
#endif
      }
      template<typename object_t>
      static void write(const object_t& message, const xtd::ustring& category) {
#if !defined(NDEBUG) || defined(DEBUG) || defined(TRACE)
        write_(xtd::ustring::format("", message), category);
#endif
      }
      template<typename ...args_t>
      static void write(const xtd::ustring& format, args_t&&... args) {
#if !defined(NDEBUG) || defined(DEBUG) || defined(TRACE)
        write_(ustring::format(format, args...));
#endif
      }
      template<typename ...args_t>
      static void write(const char* format, args_t&&... args) {
#if !defined(NDEBUG) || defined(DEBUG) || defined(TRACE)
        write_(ustring::format(format, args...));
#endif
      }
 
      static void write_if(bool condition, const xtd::ustring& message) {
#if !defined(NDEBUG) || defined(DEBUG) || defined(TRACE)
        if (condition) write_(message);
#endif
      }
      template<typename object_t>
      static void write_if(bool condition, const object_t& message) {
#if !defined(NDEBUG) || defined(DEBUG) || defined(TRACE)
        if (condition) write_(xtd::ustring::format("", message));
#endif
      }
      template<typename object_t>
      static void write_if(bool condition, const object_t& message, const xtd::ustring& category) {
#if !defined(NDEBUG) || defined(DEBUG) || defined(TRACE)
        if (condition) write_(xtd::ustring::format("", message), category);
#endif
      }
      
      static void write_line() {
#if !defined(NDEBUG) || defined(DEBUG) || defined(TRACE)
        write_line_("");
#endif
      }
      static void write_line(const xtd::ustring& message) {
#if !defined(NDEBUG) || defined(DEBUG) || defined(TRACE)
        write_line_(message);
#endif
      }
      template<typename object_t>
      static void write_line(const object_t& message) {
#if !defined(NDEBUG) || defined(DEBUG) || defined(TRACE)
        write_line_(xtd::ustring::format("", message));
#endif
      }
      template<typename object_t>
      static void write_line(const object_t& message, const xtd::ustring& category) {
#if !defined(NDEBUG) || defined(DEBUG) || defined(TRACE)
        write_line_(xtd::ustring::format("", message), category);
#endif
      }
      template<typename ...args_t>
      static void write_line(const xtd::ustring& format, args_t&&... args) {
#if !defined(NDEBUG) || defined(DEBUG) || defined(TRACE)
        write_line_(ustring::format(format, args...));
#endif
      }
      template<typename ...args_t>
      static void write_line(const char* format, args_t&&... args) {
#if !defined(NDEBUG) || defined(DEBUG) || defined(TRACE)
        write_line_(ustring::format(format, args...));
#endif
      }
 
      static void write_line_if(bool condition, const xtd::ustring& message) {
#if !defined(NDEBUG) || defined(DEBUG) || defined(TRACE)
        if (condition) write_line_(message);
#endif
      }
      template<typename object_t>
      static void write_line_if(bool condition, const object_t& message) {
#if !defined(NDEBUG) || defined(DEBUG) || defined(TRACE)
        if (condition) write_line_(message);
#endif
      }
      template<typename object_t>
      static void write_line_if(bool condition, const object_t& message, const xtd::ustring& category) {
#if !defined(NDEBUG) || defined(DEBUG) || defined(TRACE)
        if (condition) write_line_(message, category);
#endif
      }
      
      static inline bool __should_aborted__(bool condition) {return __should_aborted__(condition, "", csf_);}
      static inline bool __should_aborted__(bool condition, const xtd::ustring& message) {return __should_aborted__(condition, message, csf_);}
      static inline bool __should_aborted__(bool condition, const xtd::diagnostics::stack_frame& stack_frame) {return __should_aborted__(condition, "", stack_frame);}
      static inline bool __should_aborted__(bool condition, const xtd::ustring& message, const xtd::diagnostics::stack_frame& stack_frame) {
#if !defined(NDEBUG) || defined(DEBUG) || defined(TRACE)
        auto result = xtd::diagnostics::debug::assert_dialog(condition, 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;
      }
 
    private:
      friend trace;
      static xtd::diagnostics::assert_dialog_result assert_dialog(bool condition, const xtd::ustring& message, const xtd::diagnostics::stack_frame& stack_frame);
      static void fail__(const xtd::ustring& message);
      static void fail__(const xtd::ustring& message, const xtd::ustring& detail_message);
      static void flush_();
      static void trace_event_(trace_event_type trace_event_type, const xtd::ustring& message);
      static void write_(const xtd::ustring& message);
      static void write_(const xtd::ustring& message, const xtd::ustring& category);
      static void write_line_(const xtd::ustring& message);
      static void write_line_(const xtd::ustring& message, const xtd::ustring& category);
 
      inline static bool auto_flush_ = false;
      inline static unsigned int indent_level_ = 0;
      inline static unsigned int indent_size_ = 4;
      static listener_collection& listeners_;
      static bool& show_assert_dialog_;
      inline static bool use_global_lock_ = true;
      static std::mutex global_lock_;
      static xtd::ustring source_name_;
    };
  }
}
 
#define cassert_(...) \
  add_last_arg_to_command_(cassert, (csf_), __VA_ARGS__)
 
#define assert_(...) \
  if (xtd::diagnostics::debug::add_last_arg_to_command_(__should_aborted__, (csf_), __VA_ARGS__)) debug_break_()