console.hpp

#ifndef MSTL_CORE_SYSTEM_CONSOLE_HPP__
#define MSTL_CORE_SYSTEM_CONSOLE_HPP__
#include "../async/mutex.hpp"
#include "../utility/color.hpp"
#include "../time/duration.hpp"
MSTL_BEGIN_NAMESPACE__
 
template <typename T, typename = void>
struct io_base;
 
 
class MSTL_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) {}
 
        MSTL_NODISCARD bool operator ==(const console_size& other) const noexcept {
            return width == other.width && height == other.height;
        }
        MSTL_NODISCARD bool operator !=(const console_size& other) const noexcept {
            return !(*this == other);
        }
    };
 
private:
#ifdef MSTL_PLATFORM_WINDOWS__
    ::HANDLE out_{INVALID_HANDLE_VALUE};
    ::HANDLE in_{INVALID_HANDLE_VALUE};
 
    ::COORD saved_cursor_pos_{0, 0};
#else
    int out_{-1};
    int in_{-1};
#endif
    mutable mutex mutex_{};
    console_size last_size_{0, 0};
 
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 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;
 
    void flush_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();
 
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() {
        static sys_console console;
        return console;
    }
 
    void flush();
 
    void print_string(const string& str);
    void print_string(const string_view& str);
    void print_string(const char* str);
 
    void println();
 
    string read();
    string readln();
    char read_char();
 
    template <typename T>
    void print(const T& value) {
        io_base<T>::write(*this, value);
    }
 
    template <typename... Args>
    void printf(const string_view fmt, Args&&... args) {
        lock<mutex> lock(mutex_);
        this->print_string_unsafe(_MSTL format(fmt, _MSTL forward<Args>(args)...));
    }
 
    template <typename T>
    void printc(const color& color, const T& value) {
        set_color(color, false);
        io_base<T>::write(*this, value);
        reset_color();
    }
 
    template <typename T>
    T read() {
        package_t<T> obj;
        io_base<T>::read(*this, obj);
        return obj.value();
    }
 
    template <typename T, enable_if_t<is_packaged_v<T>, int> = 0>
    void read(T& value) {
        package_t<T> obj;
        io_base<package_t<T>>::read(*this, obj);
        value = _MSTL move(static_cast<T>(obj));
    }
 
    template <typename T, enable_if_t<!is_packaged_v<T>, int> = 0>
    void read(T& value) {
        io_base<T>::read(*this, value);
    }
 
    template <typename T>
    T readln() {
        package_t<T> obj;
        io_base<T>::readln(*this, obj);
        return obj.value();
    }
 
    template <typename T, enable_if_t<is_packaged_v<T>, int> = 0>
    void readln(T& value) {
        package_t<T> obj;
        io_base<package_t<T>>::readln(*this, obj);
        value = _MSTL move(static_cast<T>(obj));
    }
 
    template <typename T, enable_if_t<!is_packaged_v<T>, int> = 0>
    void readln(T& value) {
        io_base<T>::readln(*this, value);
    }
 
    void clear();
    void pause(string_view msg = "Press any char 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 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();
    void show_cursor();
 
    console_size get_console_size() const;
    bool is_terminal_resized();
 
    bool supports_colors() const;
    bool supports_truecolor() const;
    bool supports_unicode() const;
    bool is_interactive() const;
 
    string console_type() const;
 
    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));
};
 
 
#ifdef MSTL_STANDARD_20__
template <typename T>
struct io_base<T, enable_if_t<is_base_of_v<_MSTL_RANGES view_base<T>, T>>> {
    static void write(sys_console& console, const T& value) {
        string result;
        if (value.begin() == value.end()) {
            result = "[]";
        } else {
            result += "[ ";
            for (auto iter = value.begin(); iter != value.end(); ++iter) {
                if (iter != value.begin()) result += ", ";
                result += to_string(*iter);
            }
            result += " ]";
        }
        console.print_string(result.view());
    }
};
#endif
 
template <typename T>
struct io_base<T, enable_if_t<is_base_of_v<istringify<T>, T> && !is_base_of_v<iobject<T>, T>>> {
    static void write(sys_console& console, const T& value) {
        console.print_string(value.to_string());
    }
};
 
template <typename T>
struct io_base<T, enable_if_t<is_base_of_v<icollector<T>, T>>> {
    static void write(sys_console& console, const T& value) {
        console.print_string(to_string(value));
    }
};
 
template <typename T>
struct io_base<T, enable_if_t<is_base_of_v<iobject<T>, T>>> {
    static void write(sys_console& console, const T& value) {
        console.print_string(value.to_string());
    }
    static void read(sys_console& console, T& value) {
        value = iobject<T>::parse(console.read().view());
    }
    static void readln(sys_console& console, T& value) {
        value = iobject<T>::parse(console.readln().view());
    }
};
 
template <typename T>
struct io_base<T, enable_if_t<is_packaged_v<T>>> {
    static void write(sys_console& console, const T& value) {
        console.print_string(_MSTL to_string(value));
    }
    static void read(sys_console& console, T& value) {
        value = package_t<T>::parse(console.read().view());
    }
    static void readln(sys_console& console, T& value) {
        value = package_t<T>::parse(console.readln().view());
    }
};
 
template <typename T>
struct io_base<T, enable_if_t<is_null_pointer_v<T>>> {
    static void write(sys_console& console, nullptr_t) {
        console.print_string(_MSTL to_string(nullptr));
    }
};
 
template <typename T>
struct io_base<T, enable_if_t<is_pointer_v<T> && !is_cstring_v<T>>> {
    static void write(sys_console& console, const T& value) {
        console.print_string(_MSTL to_string(value));
    }
};
 
template <typename T, size_t N>
struct io_base<T[N], enable_if_t<is_character_v<T>>> {
    static void write(sys_console& console, const T(& value)[N]) {
        console.print_string(_MSTL to_string(value));
    }
};
 
template <typename T, size_t N>
struct io_base<const T[N], enable_if_t<is_character_v<T>>> {
    static void write(sys_console& console, const T(& value)[N]) {
        console.print_string(_MSTL to_string(value));
    }
};
 
template <typename T>
struct io_base<T*, enable_if_t<is_character_v<T>>> {
    static void write(sys_console& console, const T* value) {
        console.print_string(_MSTL to_string(value));
    }
};
 
template <typename CharT, typename Traits>
struct io_base<basic_string_view<CharT, Traits>> {
    static void write(sys_console& console, const basic_string_view<CharT, Traits>& value) {
        console.print_string(_MSTL to_string(value));
    }
};
 
template <typename CharT, typename Traits, typename Alloc>
struct io_base<basic_string<CharT, Traits, Alloc>> {
    static void write(sys_console& console, const basic_string<CharT, Traits, Alloc>& value) {
        console.print_string(_MSTL to_string(value));
    }
};
 
template <typename T>
struct io_base<T, enable_if_t<is_unbounded_array_v<T>>> {
    static void write(sys_console& console, const T& value) {
        console.print_string(_MSTL to_string(value));
    }
};
 
template <typename T>
struct io_base<T, enable_if_t<is_bounded_array_v<T> && !is_cstring_v<T>>> {
    static void write(sys_console& console, const T& value) {
        console.print_string(_MSTL to_string(value));
    }
};
 
template <typename T>
struct io_base<T, enable_if_t<is_base_of_v<exception, T>>> {
    static void write(sys_console& console, const T& value) {
        io_base<string>::write(console, _MSTL to_string(value));
    }
};
 
template <typename IfEmpty, typename T, bool Compressed>
struct io_base<compressed_pair<IfEmpty, T, Compressed>> {
    static void write(sys_console& console, const compressed_pair<IfEmpty, T, Compressed>& value) {
        io_base<string>::write(console, _MSTL to_string(value));
    }
};
 
template <typename T1, typename T2>
struct io_base<pair<T1, T2>> {
    static void write(sys_console& console, const pair<T1, T2>& value) {
        io_base<string>::write(console, _MSTL to_string(value));
    }
};
 
template <typename... Args> struct io_base<tuple<Args...>> {
    static void write(sys_console &console, const tuple<Args...> &value) {
        io_base<string>::write(console, _MSTL to_string(value));
    }
};
 
 
static sys_console& console = sys_console::instance();
 
 
#ifndef MSTL_STANDARD_17__
 
MSTL_BEGIN_INNER__
MSTL_ALWAYS_INLINE_INLINE void print_rests() {}
 
template <typename First, typename... Rests>
void print_rests(const First& first, const Rests&... rests) {
    console.print(" ");
    console.print<remove_cvref_t<First>>(first);
    _INNER print_rests(rests...);
}
 
MSTL_ALWAYS_INLINE_INLINE void printc_rests(const color&) {}
 
template <typename First, typename... Rests>
void printc_rests(const color& color, const First& first, const Rests&... rests) {
    console.print(" ");
    console.printc<remove_cvref_t<First>>(color, first);
    _INNER printc_rests(color, rests...);
}
MSTL_END_INNER__
 
template <typename This>
void print(const This& t) {
    console.print<remove_cvref_t<This>>(t);
}
 
template <typename This, typename... Rests>
void print(const This& t, const Rests&... rests) {
    console.print<remove_cvref_t<This>>(t);
    _INNER print_rests(rests...);
}
 
template <typename This>
void printc(const color& color, const This& t) {
    console.print<remove_cvref_t<This>>(color, t);
}
 
template <typename This, typename... Rests>
void printc(const color& color, const This& t, const Rests&... rests) {
    console.printc<remove_cvref_t<This>>(color, t);
    _INNER printc_rests(color, rests...);
}
 
MSTL_ALWAYS_INLINE_INLINE void println() {
    console.println();
}
 
template <typename This>
void println(const This& t) {
    console.print<remove_cvref_t<This>>(t);
    println();
}
 
template <typename This, typename... Rests>
void println(const This& t, const Rests&... rests) {
    console.print<remove_cvref_t<This>>(t);
    _INNER print_rests(rests...);
    println();
}
 
template <typename This, typename ...Rests>
void printcln(const color& color, const This& t, const Rests&... rests) {
    console.printc<remove_cvref_t<This>>(color, t);
    _INNER printc_rests(color, rests...);
    println();
}
 
#else
 
template <typename This, typename ...Rests>
void print(const This& t, const Rests&... r) {
    console.print<remove_cvref_t<This>>(t);
    ((console.print(" "), console.print<remove_cvref_t<Rests>>(r)), ...);
}
 
template <typename This, typename ...Rests>
void printc(const color& color, const This& t, const Rests&... r) {
    console.printc<remove_cvref_t<This>>(color, t);
    ((console.print(" "), console.printc<remove_cvref_t<Rests>>(color, r)), ...);
}
 
MSTL_ALWAYS_INLINE_INLINE void println() {
    console.println();
}
 
template <typename This, typename ...Rests>
void println(const This& t, const Rests&... r) {
    console.print<remove_cvref_t<This>>(t);
    ((console.print(" "), console.print<remove_cvref_t<Rests>>(r)), ...);
    println();
}
 
template <typename This, typename ...Rests>
void printcln(const color& color, const This& t, const Rests&... r) {
    console.printc<remove_cvref_t<This>>(color, t);
    ((console.print(" "), console.printc<remove_cvref_t<Rests>>(color, r)), ...);
    println();
}
 
#endif
 
template <typename... Args>
void printf(const string_view fmt, Args&&... args) {
    console.printf(fmt, _MSTL forward<Args>(args)...);
}
 
template <typename... Args>
void printfln(const string_view fmt, Args&&... args) {
    console.printf(fmt, _MSTL forward<Args>(args)...);
    println();
}
 
MSTL_END_NAMESPACE__
#endif // MSTL_CORE_SYSTEM_CONSOLE_HPP__