term_color.h

Go to the documentation of this file.

// Copyright 2012-2023:
//   GobySoft, LLC (2013-)
//   Massachusetts Institute of Technology (2007-2014)
//   Community contributors (see AUTHORS file)
// File authors:
//   Toby Schneider <toby@gobysoft.org>
//
//
// This file is part of the Goby Underwater Autonomy Project Libraries
// ("The Goby Libraries").
//
// The Goby Libraries are free software: you can redistribute them and/or modify
// them under the terms of the GNU Lesser General Public License as published by
// the Free Software Foundation, either version 2.1 of the License, or
// (at your option) any later version.
//
// The Goby Libraries are distributed in the hope that they will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public License
// along with Goby.  If not, see <http://www.gnu.org/licenses/>.
 
#ifndef GOBY_UTIL_DEBUG_LOGGER_TERM_COLOR_H
#define GOBY_UTIL_DEBUG_LOGGER_TERM_COLOR_H
 
#include <iostream> // for ostream
#include <map>      // for map
#include <string>   // for string
#include <utility>  // for pair
 
namespace goby
{
namespace util
{
const std::string esc_red = "\33[31m";
const std::string esc_lt_red = "\33[91m";
const std::string esc_green = "\33[32m";
const std::string esc_lt_green = "\33[92m";
const std::string esc_yellow = "\33[33m";
const std::string esc_lt_yellow = "\33[93m";
const std::string esc_blue = "\33[34m";
const std::string esc_lt_blue = "\33[94m";
const std::string esc_magenta = "\33[35m";
const std::string esc_lt_magenta = "\33[95m";
const std::string esc_cyan = "\33[36m";
const std::string esc_lt_cyan = "\33[96m";
const std::string esc_white = "\33[37m";
const std::string esc_lt_white = "\33[97m";
const std::string esc_nocolor = "\33[0m";
 
namespace tcolor
{
std::ostream& add_escape_code(std::ostream& os, const std::string& esc_code);
 
inline std::ostream& red(std::ostream& os) { return (add_escape_code(os, esc_red)); }
 
inline std::ostream& lt_red(std::ostream& os) { return (add_escape_code(os, esc_lt_red)); }
 
inline std::ostream& green(std::ostream& os) { return (add_escape_code(os, esc_green)); }
 
inline std::ostream& lt_green(std::ostream& os) { return (add_escape_code(os, esc_lt_green)); }
 
inline std::ostream& yellow(std::ostream& os) { return (add_escape_code(os, esc_yellow)); }
 
inline std::ostream& lt_yellow(std::ostream& os) { return (add_escape_code(os, esc_lt_yellow)); }
 
inline std::ostream& blue(std::ostream& os) { return (add_escape_code(os, esc_blue)); }
 
inline std::ostream& lt_blue(std::ostream& os) { return (add_escape_code(os, esc_lt_blue)); }
 
inline std::ostream& magenta(std::ostream& os) { return (add_escape_code(os, esc_magenta)); }
 
inline std::ostream& lt_magenta(std::ostream& os) { return (add_escape_code(os, esc_lt_magenta)); }
 
inline std::ostream& cyan(std::ostream& os) { return (add_escape_code(os, esc_cyan)); }
 
inline std::ostream& lt_cyan(std::ostream& os) { return (add_escape_code(os, esc_lt_cyan)); }
 
inline std::ostream& white(std::ostream& os) { return (add_escape_code(os, esc_white)); }
 
inline std::ostream& lt_white(std::ostream& os) { return (add_escape_code(os, esc_lt_white)); }
 
inline std::ostream& nocolor(std::ostream& os) { return (add_escape_code(os, esc_nocolor)); }
} // namespace tcolor
 
struct Colors
{
    enum Color
    {
        nocolor,
        red,
        lt_red,
        green,
        lt_green,
        yellow,
        lt_yellow,
        blue,
        lt_blue,
        magenta,
        lt_magenta,
        cyan,
        lt_cyan,
        white,
        lt_white
    };
};
 
class TermColor
{
  public:
    static Colors::Color from_str(const std::string& s) { return get_instance()->priv_from_str(s); }
 
    static std::string str_from_col(const Colors::Color& c)
    {
        return get_instance()->priv_str_from_col(c);
    }
 
    static Colors::Color from_esc_code(const std::string& s)
    {
        return get_instance()->priv_from_esc_code(s);
    }
 
    static std::string esc_code_from_col(const Colors::Color& c)
    {
        return get_instance()->priv_esc_code_from_col(c);
    }
 
    static std::string esc_code_from_str(const std::string& s)
    {
        return get_instance()->priv_esc_code_from_str(s);
    }
 
  private:
    TermColor();
    ~TermColor() = default;
 
    TermColor(const TermColor&) = delete;
    TermColor& operator=(const TermColor&) = delete;
 
    friend class TermColorDeleter;
    static std::shared_ptr<TermColor> inst_;
 
    static TermColor* get_instance();
    Colors::Color priv_from_str(const std::string& s) { return colors_map_[s]; }
 
    // red -> "red"
    std::string priv_str_from_col(const Colors::Color& c)
    {
        for (const auto& p : colors_map_)
        {
            if (p.second == c)
                return p.first;
        }
        return "nocolor";
    }
 
    // "\33[31m" -> red
    Colors::Color priv_from_esc_code(const std::string& s) { return esc_code_map_[s]; }
 
    // red -> "\33[31m"
    std::string priv_esc_code_from_col(const Colors::Color& c)
    {
        for (const auto& p : esc_code_map_)
        {
            if (p.second == c)
                return p.first;
        }
        return esc_nocolor;
    }
 
    // "red" -> "\33[31m"
    std::string priv_esc_code_from_str(const std::string& s)
    {
        return esc_code_from_col(from_str(s));
    }
 
  private:
    std::map<std::string, Colors::Color> colors_map_;
    std::map<std::string, Colors::Color> esc_code_map_;
};
 
class TermColorDeleter
{
  public:
    void operator()(TermColor* c) { delete c; }
};
 
} // namespace util
} // namespace goby
 
#endif