console.hpp

浏览该文件的文档.

#ifndef NEFORCE_CORE_SYSTEM_CONSOLE_HPP__
#define NEFORCE_CORE_SYSTEM_CONSOLE_HPP__

 
#include "NeForce/core/async/mutex.hpp"
#include "NeForce/core/exception/system_exception.hpp"
#include "NeForce/core/string/string_builder.hpp"
#include "NeForce/core/time/duration.hpp"
#include "NeForce/core/utility/color.hpp"
NEFORCE_BEGIN_NAMESPACE__


struct console_exception final : device_exception {
    explicit console_exception(const char* info = "Pipe Operation Failed.",
                               const error_code code = last_error()) noexcept :
    device_exception(info, code) {}
 
    explicit console_exception(const exception& e) :
    device_exception(e) {}
 
    ~console_exception() override = default;
 
    NEFORCE_NODISCARD const char* type() const noexcept override { return "console_exception"; }
};
 // Exceptions


class NEFORCE_API sys_console {
public:
    struct console_size {
        int width;  
        int height; 
 
        explicit console_size(const int w = 0, const int h = 0) :
        width(w),
        height(h) {}

        NEFORCE_NODISCARD bool operator==(const console_size& other) const noexcept {
            return width == other.width && height == other.height;
        }

        NEFORCE_NODISCARD bool operator!=(const console_size& other) const noexcept { return !(*this == other); }
    };
 
private:
    native_handle_type out_; 
    native_handle_type in_;  
    native_handle_type err_; 
 
#ifdef NEFORCE_PLATFORM_WINDOWS
    console_size saved_cursor_pos_{0, 0}; 
#endif
 
    mutable mutex mutex_;          
    console_size last_size_{0, 0}; 
 
    bool alt_buffer_active_ = false; // 交替缓冲区是否激活
    bool mouse_enabled_ = false;     // 鼠标输入是否开启
    int pending_char_ = -1;          // kbhit 预读的字符，-1 表示无待处理字符
 
private:
    void print_string_unsafe(const string& str) const { print_string_unsafe(str.view()); }
    void print_string_unsafe(string_view str) const;
    void print_string_unsafe(const char* str) const { print_string_unsafe(string_view{str}); }
 
    void print_error_unsafe(const string& str) const { print_error_unsafe(str.view()); }
    void print_error_unsafe(string_view str) const;
    void print_error_unsafe(const char* str) const { print_error_unsafe(string_view{str}); }
 
    void set_color_unsafe(const color& color, bool use_256_color) const;
    void typewriter_print_unsafe(string_view text, milliseconds delay_per_char, bool with_sound) const;
 
    string readln_unsafe() const;
    string read_unsafe() const;
    char read_char_unsafe() const;
    console_size get_console_size_unsafe() const;
 
    void flush_unsafe() const;
    void ignore_unsafe() const;
 
    void beep_unsafe() const;
    void flash_screen_unsafe() const;
 
    void fade_effect_unsafe(string_view text, const color& from, const color& to, milliseconds duration,
                            bool is_fade_in) const;
 
private:
    sys_console() noexcept;
 
public:
    sys_console(const sys_console&) = delete;
    sys_console& operator=(const sys_console&) = delete;
    sys_console(sys_console&&) = delete;
    sys_console& operator=(sys_console&&) = delete;
 
    ~sys_console() = default;

    static sys_console& instance() noexcept {
        static sys_console console;
        return console;
    }

    void flush();

    void ignore();

    void print_string(const string& str);

    void print_string(const string_view& view);

    void print_string(const char* str);

    void print_error(const string& str);

    void print_error(const string_view& view);

    void print_error(const char* str);

    string read();

    string readln();

    char read_char();

    template <typename... Args>
    void print(Args&&... args) {
        lock<mutex> lock(mutex_);
        this->print_string_unsafe(_NEFORCE concatenate(_NEFORCE forward<Args>(args)...));
    }

    template <typename... Args>
    void printf(const string_view fmt, Args&&... args) {
        lock<mutex> lock(mutex_);
        this->print_string_unsafe(_NEFORCE format(fmt, _NEFORCE forward<Args>(args)...));
    }

    template <typename... Args>
    void printc(const color& color, Args&&... args) {
        lock<mutex> lock(mutex_);
        this->set_color_unsafe(color, false);
        this->print_string_unsafe(_NEFORCE to_string(_NEFORCE forward<Args>(args)...));
        this->print_string_unsafe("\033[0m");
    }

    template <typename... Args>
    void printcf(const color& color, const string_view fmt, Args&&... args) {
        lock<mutex> lock(mutex_);
        this->set_color_unsafe(color, false);
        this->print_string_unsafe(_NEFORCE format(fmt, _NEFORCE forward<Args>(args)...));
        this->print_string_unsafe("\033[0m");
    }

    void println();

    template <typename... Args, enable_if_t<(sizeof...(Args) > 0), int> = 0>
    void println(Args&&... args) {
        lock<mutex> lock(mutex_);
        this->print_string_unsafe(_NEFORCE concatenate(_NEFORCE forward<Args>(args)...));
        this->print_string_unsafe("\n");
    }

    template <typename... Args>
    void printfln(const string_view fmt, Args&&... args) {
        lock<mutex> lock(mutex_);
        this->print_string_unsafe(_NEFORCE format(fmt, _NEFORCE forward<Args>(args)...));
        this->print_string_unsafe("\n");
    }

    template <typename... Args>
    void printcln(const color& color, Args&&... args) {
        lock<mutex> lock(mutex_);
        this->set_color_unsafe(color, false);
        this->print_string_unsafe(_NEFORCE concatenate(_NEFORCE forward<Args>(args)...));
        this->print_string_unsafe("\033[0m\n");
    }

    template <typename... Args>
    void printcfln(const color& color, const string_view fmt, Args&&... args) {
        lock<mutex> lock(mutex_);
        this->set_color_unsafe(color, false);
        this->print_string_unsafe(_NEFORCE format(fmt, _NEFORCE forward<Args>(args)...));
        this->print_string_unsafe("\033[0m\n");
    }

    template <typename... Args>
    void eprint(Args&&... args) {
        lock<mutex> lock(mutex_);
        this->print_error_unsafe(_NEFORCE to_string(_NEFORCE forward<Args>(args)...));
    }

    template <typename... Args>
    void eprintf(const string_view fmt, Args&&... args) {
        lock<mutex> lock(mutex_);
        this->print_error_unsafe(_NEFORCE format(fmt, _NEFORCE forward<Args>(args)...));
    }

    void eprintln();

    template <typename... Args, enable_if_t<(sizeof...(Args) > 0), int> = 0>
    void eprintln(Args&&... args) {
        lock<mutex> lock(mutex_);
        this->print_error_unsafe(_NEFORCE concatenate(_NEFORCE forward<Args>(args)...));
        this->print_error_unsafe("\n");
    }

    template <typename... Args>
    void eprintfln(const string_view fmt, Args&&... args) {
        lock<mutex> lock(mutex_);
        this->print_error_unsafe(_NEFORCE format(fmt, _NEFORCE forward<Args>(args)...));
        this->print_error_unsafe("\n");
    }

    void clear();

    void pause(string_view msg = "Press enter to continue...");

    bool confirmation(string_view prompt = "Are you sure? (y/n): ", char yes = 'y', char no = 'n');

    string password(string_view prompt = "Password: ", char mask = '*', bool show_length = false);

    void set_color(const integer32& color);

    void set_color(const color& color, bool use_256_color = true);

    void set_background_color(const color& color, bool use_256_color = true);

    void reset_color();

    void set_bold(bool enable = true);

    void set_underline(bool enable = true);

    void set_blink(bool enable = true);

    void set_reverse(bool enable = true);

    void reset_text_attributes();

    void set_window_title(string_view title);

    void set_output_utf8();

    void enable_virtual_terminal_processing(bool enable = true);

    void enable_alternate_screen_buffer(bool enable = true);

    void set_scroll_region(int top, int bottom);

    void reset_scroll_region();

    void enable_mouse(bool enable = true);

    NEFORCE_NODISCARD bool is_mouse_enabled() const;

    NEFORCE_NODISCARD bool kbhit();

    int getch();

    void progress_bar(double percentage, int width = 50, bool show_percentage = true, char fill_char = '#',
                      char empty_char = ' ');

    void set_cursor_position(int row, int column);

    void save_cursor_position();

    void restore_cursor_position();

    void hide_cursor(bool enable = true);

    NEFORCE_NODISCARD console_size get_console_size() const;

    NEFORCE_NODISCARD bool is_terminal_resized();

    NEFORCE_NODISCARD bool supports_colors() const;

    NEFORCE_NODISCARD bool supports_truecolor() const;

    NEFORCE_NODISCARD bool supports_unicode() const;

    NEFORCE_NODISCARD bool is_interactive() const;

    NEFORCE_NODISCARD string console_type() const;

    NEFORCE_NODISCARD console_size query_cursor_position();

    void typewriter_print(string_view text, milliseconds delay_per_char = milliseconds(50), bool with_sound = false);

    void typewriter_println(string_view text, milliseconds delay_per_char = milliseconds(50), bool with_sound = false);

    void beep();

    void flash_screen();

    void notification(string_view message, milliseconds duration = milliseconds(2000), bool play_sound = true);

    void fade_in(string_view text, milliseconds duration = milliseconds(1000),
                 const color& start_color = color::black(), const color& end_color = color::white());

    void fade_out(string_view text, milliseconds duration = milliseconds(1000),
                  const color& start_color = color::white(), const color& end_color = color::black());

    void fade_in_out(string_view text, milliseconds in_duration = milliseconds(500),
                     milliseconds hold_duration = milliseconds(1000), milliseconds out_duration = milliseconds(500));
};

NEFORCE_API extern sys_console& console;
 

template <typename... Args>
void print(Args&&... args) {
    console.print(_NEFORCE forward<Args>(args)...);
}

template <typename... Args>
void printc(const color& color, Args&&... args) {
    console.printc(color, _NEFORCE forward<Args>(args)...);
}

template <typename... Args>
void println(Args&&... args) {
    console.println(_NEFORCE forward<Args>(args)...);
}

template <typename... Args>
void printcln(const color& color, Args&&... args) {
    console.printcln(color, _NEFORCE forward<Args>(args)...);
}

template <typename... Args>
void printf(const string_view fmt, Args&&... args) {
    console.printf(fmt, _NEFORCE forward<Args>(args)...);
}

template <typename... Args>
void printfln(const string_view fmt, Args&&... args) {
    console.printfln(fmt, _NEFORCE forward<Args>(args)...);
}

template <typename... Args>
void printcf(const color& color, const string_view fmt, Args&&... args) {
    console.printcf(color, fmt, _NEFORCE forward<Args>(args)...);
}

template <typename... Args>
void printcfln(const color& color, const string_view fmt, Args&&... args) {
    console.printcfln(color, fmt, _NEFORCE forward<Args>(args)...);
}

template <typename... Args>
void eprint(Args&&... args) {
    console.eprint(_NEFORCE forward<Args>(args)...);
}

template <typename... Args>
void eprintf(const string_view fmt, Args&&... args) {
    console.eprintf(fmt, _NEFORCE forward<Args>(args)...);
}

template <typename... Args>
void eprintln(Args&&... args) {
    console.eprintln(_NEFORCE forward<Args>(args)...);
}

template <typename... Args>
void eprintfln(const string_view fmt, Args&&... args) {
    console.eprintfln(fmt, _NEFORCE forward<Args>(args)...);
}
 // ConsoleIO
 
NEFORCE_END_NAMESPACE__
#endif // NEFORCE_CORE_SYSTEM_CONSOLE_HPP__