debug.hpp

Go to the documentation of this file.

#pragma once
#include "../add_last_arg_to_command.hpp"
#include "../core_export.hpp"
#include "../environment.hpp"
#include "../static.hpp"
#include "../string.hpp"
#include "assert_dialog_result.hpp"
#include "debug_break.hpp"
#include "debugger.hpp"
#include "stack_trace.hpp"
#include "trace_listener_collection.hpp"
#include <cassert>

#if defined(assert)
#undef assert
#endif

namespace xtd {
  namespace forms {
    class assert_dialog;
  }
  
  namespace diagnostics {
    class trace;
    class core_export_ debug static_ {
    public:
      
      using listener_collection = xtd::diagnostics::trace_listener_collection;
      
      
      [[nodiscard]] static auto auto_flush() noexcept -> bool;
      static auto auto_flush(bool auto_flush) noexcept -> void;
      
      [[nodiscard]] static auto indent_level() noexcept -> xtd::uint32;
      static auto indent_level(xtd::uint32 indent_level) noexcept -> void;
      
      [[nodiscard]] static auto indent_size() noexcept -> xtd::uint32;
      static auto indent_size(xtd::uint32 indent_size) noexcept -> void;
      
      [[nodiscard]] static auto listeners() -> listener_collection&;
      static auto listeners(const listener_collection& listeners) -> void;
      
      [[nodiscard]] static auto use_global_lock() noexcept -> bool;
      static auto use_global_lock(bool use_global_lock) noexcept -> void;
      
      
      static auto assert(bool condition, const xtd::diagnostics::stack_frame& stack_frame = xtd::diagnostics::stack_frame::current()) -> void {
        #if DEBUG
        if (__should_aborted__(stack_frame, condition, string::empty_string)) debug_break_();
        #endif
      }

      static auto assert(bool condition, const xtd::string& message, const xtd::diagnostics::stack_frame& stack_frame = xtd::diagnostics::stack_frame::current()) -> void {
        #if DEBUG
        if (__should_aborted__(stack_frame, condition, message)) debug_break_();
        #endif
      }

      static auto assert(bool condition, const xtd::string& message, const xtd::string& detail_message, const xtd::diagnostics::stack_frame& stack_frame = xtd::diagnostics::stack_frame::current()) -> void {
        #if DEBUG
        if (__should_aborted__(stack_frame, condition, message, detail_message)) debug_break_();
        #endif
      }

      [[deprecated("Use xtd::diagnostics::debug::assert method - Will be removed in version 1.2.0.)")]]
      static auto cassert(bool condition, const xtd::diagnostics::stack_frame& stack_frame = xtd::diagnostics::stack_frame::current()) -> void {
        #if DEBUG
        if (__should_aborted__(stack_frame, condition, string::empty_string)) debug_break_();
        #endif
      }

      [[deprecated("Use xtd::diagnostics::debug::assert method - Will be removed in version 1.2.0.)")]]
      static auto cassert(bool condition, const xtd::string& message, const xtd::diagnostics::stack_frame& stack_frame = xtd::diagnostics::stack_frame::current()) -> void {
        #if DEBUG
        if (__should_aborted__(stack_frame, condition, message)) debug_break_();
        #endif
      }

      [[deprecated("Use xtd::diagnostics::debug::assert method - Will be removed in version 1.2.0.)")]]
      static auto cassert(bool condition, const xtd::string& message, const xtd::string& detail_message, const xtd::diagnostics::stack_frame& stack_frame = xtd::diagnostics::stack_frame::current()) -> void {
        #if DEBUG
        if (__should_aborted__(stack_frame, condition, message, detail_message)) debug_break_();
        #endif
      }
      
      static auto fail(const xtd::string& message) -> void {
        #if DEBUG
        fail__(message);
        #endif
      }

      static auto fail(const xtd::string& message, const xtd::string& detail_message) -> void {
        #if DEBUG
        fail__(message, detail_message);
        #endif
      }
      
      static auto flush() -> void {
        #if DEBUG
        flush_();
        #endif
      }
      
      static auto indent() noexcept -> void;
      
      static auto print(const xtd::string& message) -> void {
        #if DEBUG
        write_line_(message);
        #endif
      }

      template<typename ...args_t>
      static auto print(const xtd::string& format, args_t&& ... args) -> void {
        #if DEBUG
        write_line_(xtd::string::format(format, args...));
        #endif
      }

      template<typename ...args_t>
      static auto print(const char* format, args_t&& ... args) -> void {
        #if DEBUG
        write_line_(xtd::string::format(format, args...));
        #endif
      }
      
      static auto trace_error(const xtd::string& message) -> void {
        #if DEBUG
        trace_event_(xtd::diagnostics::trace_event_type::error, message);
        #endif
      }

      template<typename ...objects_t>
      static auto trace_error(const xtd::string& message, const objects_t& ... args) -> void {
        #if DEBUG
        trace_event_(xtd::diagnostics::trace_event_type::error, xtd::string::format(message, args...));
        #endif
      }
      
      static auto trace_information(const xtd::string& message) -> void {
        #if DEBUG
        trace_event_(xtd::diagnostics::trace_event_type::information, message);
        #endif
      }

      template<typename ...objects_t>
      static auto trace_information(const xtd::string& message, const objects_t& ... args) -> void {
        #if DEBUG
        trace_event_(xtd::diagnostics::trace_event_type::information, xtd::string::format(message, args...));
        #endif
      }
      
      static auto trace_warning(const xtd::string& message) -> void {
        #if DEBUG
        trace_event_(xtd::diagnostics::trace_event_type::warning, message);
        #endif
      }

      template<typename ...objects_t>
      static auto trace_warning(const xtd::string& message, const objects_t& ... args) -> void {
        #if DEBUG
        trace_event_(xtd::diagnostics::trace_event_type::warning, xtd::string::format(message, args...));
        #endif
      }
      
      static auto unindent() noexcept -> void;
      
      static auto write(const xtd::string& message) -> void {
        #if DEBUG
        write_(message);
        #endif
      }

      template<typename object_t>
      static auto write(const object_t& message) -> void {
        #if DEBUG
        write_(xtd::string::format("{}", message));
        #endif
      }

      template<typename object_t>
      static auto write(const object_t& message, const xtd::string& category) -> void {
        #if DEBUG
        write_(xtd::string::format("{}", message), category);
        #endif
      }

      template<typename ...args_t>
      static auto write(const xtd::string& format, args_t&& ... args) -> void {
        #if DEBUG
        write_(xtd::string::format(format, args...));
        #endif
      }

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

      template<typename object_t>
      static auto write_if(bool condition, const object_t& message) -> void {
        #if DEBUG
        if (condition) write_(xtd::string::format("{}", message));
        #endif
      }

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

      static auto write_line(const xtd::string& message) -> void {
        #if DEBUG
        write_line_(message);
        #endif
      }

      template<typename object_t>
      static auto write_line(const object_t& message) -> void {
        #if DEBUG
        write_line_(xtd::string::format("{}", message));
        #endif
      }

      template<typename object_t>
      static auto write_line(const object_t& message, const xtd::string& category) -> void {
        #if DEBUG
        write_line_(xtd::string::format("{}", message), category);
        #endif
      }

      template<typename ...args_t>
      static auto write_line(const xtd::string& format, args_t&& ... args) -> void {
        #if DEBUG
        write_line_(xtd::string::format(format, args...));
        #endif
      }

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

      template<typename object_t>
      static auto write_line_if(bool condition, const object_t& message) -> void {
        #if DEBUG
        if (condition) write_line_(message);
        #endif
      }

      template<typename object_t>
      static auto write_line_if(bool condition, const object_t& message, const xtd::string& category) -> void {
        #if DEBUG
        if (condition) write_line_(message, category);
        #endif
      }

      
      static auto __should_aborted__(const xtd::diagnostics::stack_frame& stack_frame, bool condition) -> bool {return __should_aborted__(stack_frame, condition, xtd::string::empty_string);}
      static auto __should_aborted__(const xtd::diagnostics::stack_frame& stack_frame, bool condition, const xtd::string& message) -> bool {return __should_aborted__(stack_frame, condition, message, xtd::string::empty_string);}
      static auto __should_aborted__(const xtd::diagnostics::stack_frame& stack_frame, bool condition, const xtd::string& message, const xtd::string& detail_message) -> bool {
        #if DEBUG
        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 1.2.0.")]]
      [[nodiscard]] static auto show_assert_dialog() noexcept -> bool;
      [[deprecated("Replaced by xtd::diagnostics::default_trace_listener::assert_ui_enabled - Will be removed in version 1.2.0.")]]
      static auto show_assert_dialog(bool show_assert_dialog) noexcept -> void;
      
    private:
      friend trace;
      friend xtd::forms::assert_dialog;
      static auto assert_dialog(bool condition, const xtd::string& message, const xtd::string& detail_message, const xtd::diagnostics::stack_frame& stack_frame) -> xtd::diagnostics::assert_dialog_result;
      static auto assert_dialog_caption() -> xtd::string;
      static auto internal_show_assert_dialog() noexcept -> bool;
      static auto fail__(const xtd::string& message) -> void;
      static auto fail__(const xtd::string& message, const xtd::string& detail_message) -> void;
      static auto flush_() -> void;
      static auto trace_event_(xtd::diagnostics::trace_event_type trace_event_type, const xtd::string& message) -> void;
      static auto write_(const xtd::string& message) -> void;
      static auto write_(const xtd::string& message, const xtd::string& category) -> void;
      static auto write_line_(const xtd::string& message) -> void;
      static auto write_line_(const xtd::string& message, const xtd::string& category) -> void;
      
      inline static bool auto_flush_ = false;
      inline static xtd::uint32 indent_level_ = 0;
      inline static xtd::uint32 indent_size_ = 4;
      static listener_collection& listeners_;
      inline static bool use_global_lock_ = true;
    };
  }
}