util/liblogger/term_color.h

//
// this file is part of flex-ostream, a terminal display library
// that provides an ostream with both terminal display and file logging
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This software is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this software.  If not, see <http://www.gnu.org/licenses/>.

#ifndef TermColor20091211H
#define TermColor20091211H

#include <iostream>
#include <string>

#include <boost/assign.hpp>
#include <boost/foreach.hpp>

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)); }    
        }

        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();            
            TermColor(const TermColor&);
            TermColor& operator = (const TermColor&);

            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)
            {
                typedef std::pair<std::string, Colors::Color> P;
                BOOST_FOREACH(const P& 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)
            {
                typedef std::pair<std::string, Colors::Color> P;
                BOOST_FOREACH(const P& 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:        
            static TermColor* inst_;
            std::map<std::string, Colors::Color> colors_map_;
            std::map<std::string, Colors::Color> esc_code_map_;
        };    
    }
}

#endif