termstyle.hpp

Go to the documentation of this file.

 
#pragma once
#ifndef TERMSTYLE_HPP
#define TERMSTYLE_HPP
 
#include <iostream>
#include <stdexcept>
 
#define TERMSTYLE_NODISCARD [[nodiscard]]
 
#define TERMSTYLE_ERROR_DEF(parent, name)                         \
protected:                                                        \
    name(std::string ename, std::string msg, int exit_code)       \
        : parent(std::move(ename), std::move(msg), exit_code) {}  \
    name(std::string ename, std::string msg, ExitCodes exit_code) \
        : parent(std::move(ename), std::move(msg), exit_code) {}  \
                                                                  \
public:                                                           \
    name(std::string msg, ExitCodes exit_code)                    \
        : parent(#name, std::move(msg), exit_code) {}             \
    name(std::string msg, int exit_code)                          \
        : parent(#name, std::move(msg), exit_code) {}
 
#define TERMSTYLE_ERROR_SIMPLE(name) \
    explicit name(std::string msg) : name(#name, msg, ExitCodes::name) {}
 
enum class ExitCodes : int
{
    SUCCESS = 0,
    IncorrectConstruction = 100,
    PresetNameUsed,
    PresetNotFound,
    BadColorID,
    BaseClass = 200
};
 
class Error : public std::runtime_error
{
    int exit_code;
    std::string error_name{"Error"};
 
public:
    TERMSTYLE_NODISCARD int getExitCode() const
    {
        return exit_code;
    }
 
    TERMSTYLE_NODISCARD std::string getErrorName() const
    {
        return error_name;
    }
 
    Error(std::string name, std::string msg, int exit_code = static_cast<int>(ExitCodes::BaseClass))
        : std::runtime_error(msg), exit_code(exit_code), error_name(name) {}
 
    Error(std::string name, std::string msg, ExitCodes exit_code) : Error(name, msg,
                                                                          static_cast<int>(exit_code)) {}
};
 
class PresetNameUsed : public Error
{
    TERMSTYLE_ERROR_DEF(Error, PresetNameUsed)
    explicit PresetNameUsed(std::string name)
        : PresetNameUsed("Preset name \"" + name + "\" is already used.", ExitCodes::PresetNameUsed) {}
};
 
class PresetNotFound : public Error
{
    TERMSTYLE_ERROR_DEF(Error, PresetNotFound)
    explicit PresetNotFound(std::string name)
        : PresetNotFound("Preset \"" + name + "\" not found.", ExitCodes::PresetNotFound) {}
};
 
class BadColorID : public Error
{
    TERMSTYLE_ERROR_DEF(Error, BadColorID)
    TERMSTYLE_ERROR_SIMPLE(BadColorID);
};
 
#undef TERMSTYLE_ERROR_DEF
#undef TERMSTYLE_ERROR_SIMPLE
 
 // end of Error_group
 
#include <string>
#include <vector>
#include <map>
 
namespace termstyle
{
 
    enum class Codes : int
    {
        RESTORE = 0,
        BRIGHT = 1,
        DIM = 2,
        ITALIC = 3,
        UNDERLINE = 4,
        FLASH = 5,
        REVERSE = 7,
        HIDDEN = 8,
        STRIKE = 9,
 
        BRIGHT_RESET = 22, // reset bright and dim
        DIM_RESET = 22,
        ITALIC_RESET = 23,
        UNDERLINE_RESET = 24,
        FLASH_RESET = 25,
        REVERSE_RESET = 27,
        HIDDEN_RESET = 28,
        STRIKE_RESET = 29,
 
        FOREGROUND_BLACK = 30,
        FOREGROUND_RED = 31,
        FOREGROUND_GREEN = 32,
        FOREGROUND_YELLOW = 33,
        FOREGROUND_BLUE = 34,
        FOREGROUND_PURPLE = 35,
        FOREGROUND_CYAN = 36,
        FOREGROUND_WHITE = 37,
 
        FOREGROUND_RESET = 39,
 
        BACKGROUND_BLACK = 40,
        BACKGROUND_RED = 41,
        BACKGROUND_GREEN = 42,
        BACKGROUND_YELLOW = 43,
        BACKGROUND_BLUE = 44,
        BACKGROUND_PURPLE = 45,
        BACKGROUND_CYAN = 46,
        BACKGROUND_WHITE = 47,
 
        BACKGROUND_RESET = 49
    };
 
    template<typename T>
    std::string code2string(const std::vector<T>& codelist) noexcept
    {
        if (codelist.empty()) return "";
        std::string res = "\033[";
        for (size_t i = 0; i < codelist.size(); i++)
        {
            res += std::to_string(static_cast<int>(codelist[i]));
            if (i != codelist.size() - 1)
            {
                res += ";";
            }
        }
        res += "m";
        return res;
    }
 
    std::string code2string(const Codes &col)
    {
        return "\033[" + std::to_string(static_cast<int>(col)) + "m";
    }
 
 // end of Col16_group
 
    enum class ColorMode : int
    {
        FOREGROUND = 38,
        BACKGROUND = 48
    };
 
    enum class ColorType : int
    {
        COL16 = 0,
        COL256 = 1,
        COLRGB = 2
    };
 
    bool validateColorID(int ID)
    {
        return ID >= 0 && ID <= 255;
    }
 
    struct Col256
    {
        ColorMode mode;
        int ID;
        explicit Col256(ColorMode mode, int ID) : mode(mode), ID(ID) {
            if (!validateColorID(ID))
            {
                throw BadColorID("Invalid color ID: " + std::to_string(ID));
            }
        }
    };
 
    std::string col256_2string(std::vector<Col256> codelist) noexcept
    {
        if (codelist.empty()) return "";
        std::string res = "\033[";
        for (size_t i = 0; i < codelist.size(); i++)
        {
            res += std::to_string(static_cast<int>(codelist[i].mode)) + ";5;" + std::to_string(codelist[i].ID);
            if (i != codelist.size() - 1)
            {
                res += ";";
            }
        }
        res += "m";
        return res;
    }
    
    std::string col256_2string(const Col256 &col) noexcept
    {
        std::string res = "\033[";
        res += std::to_string(static_cast<int>(col.mode)) + ";5;";
        res += std::to_string(col.ID) + "m";
        return res;
    }
 
 // end of Col256_group
 
    struct ColRGB
    {
        ColorMode mode;
        int r, g, b;
 
        explicit ColRGB(ColorMode mode, int r, int g, int b) : mode(mode), r(r), g(g), b(b) {}
    };
 
    std::string colrgb_2string(const ColRGB &col) noexcept
    {
        std::string res = "\033[";
        res += std::to_string(static_cast<int>(col.mode)) + ";2;";
        res += std::to_string(col.r) + ";";
        res += std::to_string(col.g) + ";";
        res += std::to_string(col.b) + "m";
        return res;
    }
 
 // end of ColRGB_group
 
    struct Color
    {
        ColorType type;
        union {
            Codes col16;
            Col256 col256;
            ColRGB colrgb;
        };
 
        explicit Color(Codes col16) : type(ColorType::COL16), col16(col16) {}
        explicit Color(Col256 col256) : type(ColorType::COL256), col256(col256) {}
        explicit Color(ColRGB colrgb) : type(ColorType::COLRGB), colrgb(colrgb) {}
    };
 
    struct StyleString
    {
        std::string text = "";
 
        std::vector<Color> prestyles = {};
 
        std::vector<Color> poststyles = {};
 
        std::vector<Codes> prestyle16 = {};
 
        std::vector<Codes> poststyle16 = {};
 
        std::vector<Col256> prestlye256 = {};
        
        std::vector<Col256> poststyle256 = {};
    };
 
    struct Config
    {
        bool leading_restore = true;
        bool trailing_restore = true;
 
        bool trailing_newline = true;
    };
 
    struct PresetConfig
    {
        StyleString prefix;
        StyleString suffix;
        Config config;
    };
 
 // end of Construct_group
 
    std::map<std::string, PresetConfig> presets = {};
 
    enum class ParseMode : int
    {
        ALL = 0,
        PREFIX = 1,
        SUFFIX = 2
    };
 
    std::string parseColortype(std::vector<Color> codelist) noexcept
    {
        if (codelist.empty()) return "";
        std::string res = "";
        for (size_t i = 0; i < codelist.size(); i++)
        {
            switch (codelist[i].type)
            {
            case ColorType::COL16:
                res += code2string(codelist[i].col16);
                break;
            case ColorType::COL256:
                res += col256_2string(codelist[i].col256);
                break;
            case ColorType::COLRGB:
                res += colrgb_2string(codelist[i].colrgb);
                break;
            default:
                break;
            }
        }
        return res;
    }
 
    std::string parse(const PresetConfig &preset, ParseMode mode = ParseMode::ALL) noexcept
    {
        if (mode == ParseMode::PREFIX)
        {
            return code2string(preset.prefix.prestyle16)
                   + col256_2string(preset.prefix.prestlye256)
                   + parseColortype(preset.prefix.prestyles)
                   + preset.prefix.text
                   + code2string(preset.prefix.poststyle16)
                   + col256_2string(preset.prefix.poststyle256)
                   + parseColortype(preset.prefix.poststyles);
        }
        if (mode == ParseMode::SUFFIX)
        {
            return code2string(preset.suffix.prestyle16)
                   + col256_2string(preset.suffix.prestlye256)
                   + parseColortype(preset.suffix.prestyles)
                   + preset.suffix.text
                   + code2string(preset.suffix.poststyle16)
                   + col256_2string(preset.suffix.poststyle256)
                   + parseColortype(preset.suffix.poststyles)
                   + (preset.config.trailing_newline ? "\n" : "");
        }
        if (mode == ParseMode::ALL)
        {
            return code2string(preset.prefix.prestyle16)
                   + col256_2string(preset.prefix.prestlye256)
                   + parseColortype(preset.prefix.prestyles)
                   + preset.prefix.text
                   + code2string(preset.prefix.poststyle16)
                   + col256_2string(preset.prefix.poststyle256)
                   + parseColortype(preset.prefix.poststyles)
 
                   + code2string(preset.suffix.prestyle16)
                   + col256_2string(preset.suffix.prestlye256)
                   + parseColortype(preset.suffix.prestyles)
                   + preset.suffix.text
                   + code2string(preset.suffix.poststyle16)
                   + col256_2string(preset.suffix.poststyle256)
                   + parseColortype(preset.suffix.poststyles)
 
                   + (preset.config.trailing_newline ? "\n" : "");
        }
        return "";
    }
 
    void addPreset(std::string name, PresetConfig preset)
    {
        if (presets.find(name) != presets.end()) // preset already exists
        {
            throw PresetNameUsed(name);
        }
 
        if (preset.config.leading_restore)
        {
            preset.prefix.prestyles.insert(preset.prefix.prestyles.begin(), Color(Codes::RESTORE));
        }
        if (preset.config.trailing_restore)
        {
            preset.suffix.poststyles.emplace_back(Color(Codes::RESTORE));
        }
 
        presets[name] = std::move(preset);
    }
 
    void print(std::string preset, std::string text = "")
    {
        if (presets.find(preset) == presets.end())
        {
            throw PresetNotFound(preset);
        }
        const PresetConfig &config = presets[preset];
        std::cout << parse(config, ParseMode::PREFIX) << text << parse(config, ParseMode::SUFFIX);
    }
 
    class StyledCout
    {
    private:
        const PresetConfig &config;
 
    public:
        explicit StyledCout(const PresetConfig &config) : config(config)
        {
            std::cout << parse(config, ParseMode::PREFIX);
        }
 
        ~StyledCout()
        {
            std::cout << parse(config, ParseMode::SUFFIX);
        }
 
        template<typename T>
        std::ostream& operator<<(const T& value)
        {
            return std::cout << value;
        }
    };
 
    StyledCout style(const std::string &preset)
    {
        if (presets.find(preset) == presets.end())
        {
            throw PresetNotFound(preset);
        }
        return StyledCout(presets[preset]);
    }
 
    class OnExit
    {
    public:
        ~OnExit()
        {
            std::cout << code2string<Codes>({Codes::RESTORE});
        }
    };
 
    OnExit onExitInstance;
 
} // namespace termstyle
 
#endif // TERMSTYLE_HPP