JColorFacet.hh

Go to the documentation of this file.

#ifndef __JLANG__JCOLORFACET__
#define __JLANG__JCOLORFACET__
 
#include <locale>
#include <ostream>
#include <string>
#include <vector>
#include <map>
 
#include "JLang/JType.hh"
#include "JLang/JTypeList.hh"
#include "JLang/JSinglePointer.hh"
#include "JLang/JException.hh"
 
 
/**
 * \author mdejong
 */
 
namespace JLANG {}
namespace JPP { using namespace JLANG; }
 
 
namespace JLANG {
 
  /**
   * Enumeration of text colors.
   */
  enum JColor_t {
    RED,              //!< red
    GREEN,            //!< green
    BLUE,             //!< blue
    WHITE,            //!< white
    CYAN,             //!< cyan
    PURPLE,           //!< purple
    YELLOW,           //!< yellow
    RESET,            //!< reset
    BOLD              //!< bold
  };
 
 
  /**
   * Facet interface to specify text color.
   * This class extends the std::locale::facet class.
   */
  struct JColorFacet : 
    public std::locale::facet
  {
    static std::locale::id  id;
 
  
    /**
     * Constructor.
     *
     * \param  refs      reference count
     */
    JColorFacet(std::size_t refs = 0) :
      std::locale::facet(refs)
    {}
 
 
    /**
     * Print color.
     *
     * \param  color     code
     * \return           text
     */
    virtual const char* c_str(const JColor_t color) const = 0;
 
 
    /**
     * Clone this facet.
     *
     * \return           pointer to newly created facet
     */
    virtual JColorFacet* clone() const = 0;
 
 
    /**
     * Check color.
     *
     * \param  color     code
     * \return           true if color; else false
     */
    static inline bool is_color(const int color)
    {
      return !is_bold(color) && !is_reset(color);
    }
 
 
    /**
     * Check bold.
     *
     * \param  color     code
     * \return           true if bold; else false
     */
    static inline bool is_bold(const int color)
    {
      return color == BOLD;
    }
 
 
    /**
     * Check reset.
     *
     * \param  color     code
     * \return           true if reset; else false
     */
    static inline bool is_reset(const int color)
    {
      return color == RESET;
    }
  private:
 
    JColorFacet(const JColorFacet&);          // not defined
    void operator=(const JColorFacet&);       // not defined
  };
 
 
  /**
   * Facet class to specify text color for ASCII.
   */
  struct JColorFacetASCII : 
    public JColorFacet
  {
    /**
     * Get name of facet.
     *
     * \return           name
     */
    static inline const char* getName() 
    {
      return "ASCII";
    }
 
 
    /**
     * Constructor.
     *
     * \param  refs      reference count
     */
    JColorFacetASCII(std::size_t refs = 0) :
      JColorFacet(refs)
    {}
 
 
    /**
     * Print color.
     *
     * \param  color     code
     * \return           text
     */
    virtual const char* c_str(const JColor_t color) const override 
    {
      switch (color) {
      case RED:     return "\033[91m"; 
      case GREEN:   return "\033[92m"; 
      case BLUE:    return "\033[94m";
      case WHITE:   return "\033[97m";
      case CYAN:    return "\033[96m";
      case PURPLE:  return "\033[95m";
      case YELLOW:  return "\033[93m";
      case BOLD:    return "\033[1m";
      case RESET:   return "\033[0m";
      default:      return "";
      }
    }
 
 
    /**
     * Clone this facet.
     *
     * \return           pointer to newly created facet
     */
    virtual JColorFacetASCII* clone() const override 
    {
      return new JColorFacetASCII();
    }
  };
 
 
  /**
   * Facet class to specify text color for ELcode.
   */
  struct JColorFacetELcode : 
    public JColorFacet
  {
    /**
     * Get name of facet.
     *
     * \return           name
     */
    static inline const char* getName() 
    {
      return "ELcode";
    }
 
 
    /**
     * Constructor.
     *
     * \param  refs      reference count
     */
    JColorFacetELcode(std::size_t refs = 0) :
      JColorFacet(refs)
    {}
 
 
    /**
     * Print color.
     *
     * \param  color     code
     * \return           text
     */
    virtual const char* c_str(const JColor_t color) const override 
    {
      static std::string buffer;
 
      history.push_back(color);
 
      switch (color) {
 
      case RED:    return "[color=red]";
      case GREEN:  return "[color=green]";
      case BLUE:   return "[color=blue]";
      case WHITE:  return "[color=white]";
      case CYAN:   return "[color=cyan]";
      case PURPLE: return "[color=purple]";
      case YELLOW: return "[color=yellow]";
      case BOLD:   return "[bold]";
 
      case RESET:
 
        buffer.clear();
 
        for (std::vector<int>::const_reverse_iterator i = history.rbegin(); i != history.rend(); ++i) {
          if      (is_color(*i)) 
            buffer += "[/color]";
          else if (is_bold (*i)) 
            buffer += "[/bold]";
          else
            ;
        }
 
        history.clear();
 
        return buffer.c_str();
        
      default:     return "";
      }
    }
 
 
    /**
     * Clone this facet.
     *
     * \return           pointer to newly created facet
     */
    virtual JColorFacetELcode* clone() const override 
    {
      return new JColorFacetELcode();
    }
 
  private:
    mutable std::vector<int> history;
  };
 
 
  /**
   * Typelist of color facets.
   */
  typedef JTYPELIST<JColorFacetASCII, JColorFacetELcode>::typelist    JColorFacetTypes_t;
 
 
  /**
   * Auxiliary map for color facets.
   */
  struct JColorFacetMap_t :
    public std::map<std::string, JSinglePointer<JColorFacet> >
  {
    typedef std::map<std::string, JSinglePointer<JColorFacet> >  map_type;
    typedef typename map_type::key_type                          key_type;
    typedef typename map_type::mapped_type                       mapped_type;
    typedef typename map_type::value_type                        value_type;
 
 
    /**
     * Default constructor.
     */
    JColorFacetMap_t()
    {
      for_each(*this, JType<JColorFacetTypes_t>());
    }
 
 
    /**
     * Get value for given key.
     *
     * Note that this method will throw an error if given key is absent.
     *
     * \param  key       key
     * \return           value
     */
    const mapped_type& operator[](const key_type& key) const
    {
      const_iterator p = find(key);
 
      if (p != this->end()) {
        return p->second;
      }
 
      THROW(JNullPointerException, "Invalid key " << key);
    }
 
 
    /**
     * Insert data type.
     *
     * \param  type      data type
     */
    template<class T>
    void operator()(const JType<T>& type) 
    {
      insert(value_type(T::getName(), new T()));
    }
  };
 
 
  /**
   * Color facets.
   */
  static const JColorFacetMap_t   color_facets;
}
 
 
/**
 * Print color.
 *
 * \param  out               output stream
 * \param  color             color
 * \return                   output stream
 */
inline std::ostream& operator<<(std::ostream& out, const JLANG::JColor_t color)
{
  using namespace std;
  using namespace JPP;
 
  const locale& loc = out.getloc();
          
  if      (has_facet<JColorFacetASCII>(loc)) 
    return out << use_facet<JColorFacetASCII> (loc).c_str(color);
  else if (has_facet<JColorFacetELcode>(loc)) 
    return out << use_facet<JColorFacetELcode>(loc).c_str(color);
  else
    return out << JColorFacetASCII().c_str(color);
}
 
#endif