printer.hpp

浏览该文件的文档.

/*
 * @Description: 打印器类 头文件及其实现
 * @Version:
 * @Autor: dreamy-xay
 * @date: 2024-01-23
 * @LastEditors: dreamy-xay
 * @LastEditTime: 2024-03-04
 */
 
#ifndef COMMON_PRINTER_HPP
#define COMMON_PRINTER_HPP
 
#include <cstring>
#include <iostream>
#include <regex>
 
#include "common/debug/color.hpp"
#include "common/enum.h"
#include "common/macro.h"
#include "common/type.h"
#include "common/utils/string.hpp"
 
namespace cm {
 
class Printer {
   protected:
    std::string default_split_string;  // 默认打印分隔字符串
    std::string output_color;          // 默认输出内容的颜色
    std::string split_string;          // 临时打印分隔字符串
    bool use_temp_split_string;        // 是否使用临时分隔字符串
    bool is_cancel_color;              // 打印时是否撤销了颜色
    bool is_first_print;               // 是否第一次打印
 
    std::string output_color_cache;  // 默认输出内容的颜色缓存
   public:
    Printer(const std::string& default_split_string = " ", const std::string& output_color = Color::BLUE);
    ~Printer();
 
    template <typename T>
    static bool IsMatchString(T arg, const char* match_string, bool is_regex = false);
    static bool IsMatchString(const char* arg, const char* match_string, bool is_regex = false);
 
    template <typename T>
    Printer& Print(T arg);
    template <typename T, typename... ARGS>
    Printer& Print(T arg, ARGS... args);
 
    template <typename... ARGS>
    std::ostream& operator()(ARGS... args);
 
    Printer& SetOutputColor(const std::string& output_color);
    Printer& SetSplitString(const std::string& split_string);
 
   private:
    template <typename T>
    void PrintArg(T arg, bool is_last_arg = false);
 
    virtual std::string GetPrintPrefix(bool is_last_arg);
 
    template <typename T>
    static std::string ToString(T arg);
    static std::string ToString(const char* arg);
};
 
inline Printer::Printer(const std::string& split_string, const std::string& output_color) : default_split_string(split_string), output_color(output_color), split_string(""), use_temp_split_string(false), is_cancel_color(false), is_first_print(true) {}
 
inline Printer::~Printer() {}
 
template <typename T>
inline bool Printer::IsMatchString(T arg, const char* match_string, bool is_regex) {
    return false;
}
 
inline bool Printer::IsMatchString(const char* arg, const char* match_string, bool is_regex) {
    if (is_regex)
        return std::regex_match(arg, std::regex(match_string));
    else
        return std::strcmp(arg, match_string) == 0;
}
 
template <typename T>
inline Printer& Printer::Print(T arg) {
    // 是否特殊字符串
    bool is_special_string = Printer::IsMatchString(arg, "__NO_COLOR__") || Printer::IsMatchString(arg, "__SPLIT=.*__", true);
 
    // 如果不是特殊字符串则打印参数
    if (!is_special_string)
        this->PrintArg(arg, true);
 
    // 如果取消了颜色打印则恢复颜色打印
    if (is_cancel_color) {
        is_cancel_color = false;
        output_color = output_color_cache;  // 恢复缓存颜色
        Color::RestoreColor();
    }
 
    // 如果使用了临时分隔字符串，则清除
    if (use_temp_split_string) {
        use_temp_split_string = false;
        split_string.clear();
    }
 
    is_first_print = true;  // 重载是否第一次打印变量，保证下一次打印重头开始
 
    return *this;
}
 
template <typename T, typename... ARGS>
inline Printer& Printer::Print(T arg, ARGS... args) {
    // 如果需要取消打印颜色，则取消，并且不打印参数
    if (Printer::IsMatchString(arg, "__NO_COLOR__")) {
        is_cancel_color = true;
        output_color_cache = output_color;  // 缓存原始输出颜色
        output_color = "";
        Color::CancelColor();
    } else if (Printer::IsMatchString(arg, "__SPLIT=.*__", true)) {  // 设置临时分隔字符串
        use_temp_split_string = true;
        // 更新分隔字符串
        std::string arg_str = Printer::ToString(arg);
        std::size_t start = arg_str.find_first_of("=") + 1;
        std::size_t end = arg_str.find_last_of("__") - 1;
        split_string = arg_str.substr(start, end - start);
    } else  // 否则打印参数
        this->PrintArg(arg);
 
    // 递归调用不定参数打印
    this->Print(args...);
 
    return *this;
}
 
template <typename... ARGS>
inline std::ostream& Printer::operator()(ARGS... args) {
    this->Print(args...);
 
    return std::cout;
}
 
inline Printer& Printer::SetOutputColor(const std::string& output_color) {
    this->output_color = output_color;
 
    return *this;
}
 
inline Printer& Printer::SetSplitString(const std::string& split_string) {
    default_split_string = split_string;
 
    return *this;
}
 
template <typename T>
inline void Printer::PrintArg(T arg, bool is_last_arg) {
    if (is_first_print)  // 第一次打印不输出分隔符
        is_first_print = false;
    else
        std::cout << (use_temp_split_string ? split_string : default_split_string);
 
    std::cout << this->GetPrintPrefix(is_last_arg) << output_color << arg << Color::RESET;  // 打印参数值
}
 
inline std::string Printer::GetPrintPrefix(bool is_last_arg) {
    return "";
}
 
template <typename T>
inline std::string Printer::ToString(T arg) {
    return "";
}
 
inline std::string Printer::ToString(const char* arg) {
    return arg;
}
 
}  // namespace cm
 
#endif