ansi.h

Go to the documentation of this file.

/*---------------------------------------------------------------------\
|                          ____ _   __ __ ___                          |
|                         |__  / \ / / . \ . \                         |
|                           / / \ V /|  _/  _/                         |
|                          / /__ | | | | | |                           |
|                         /_____||_| |_| |_|                           |
|                                                                      |
----------------------------------------------------------------------/
*
* This file contains private API, this might break at any time between releases.
* Strictly for internal use!
*/
 
#ifndef ZYPP_TUI_UTILS_ANSI_H
#define ZYPP_TUI_UTILS_ANSI_H
 
#include <cstdint>
#include <iostream>
#include <sstream>
#include <type_traits>
#include <memory>
#include <map>
#include <string>
 
#include <zypp/base/String.h>
 
 
namespace ztui {

bool do_ttyout();      // implemented in colors.cc

bool do_colors();      // implemented in colors.cc

bool mayUseANSIEscapes();

bool hasANSIColor();

namespace ansi
{
  namespace tty
  {
    class EscapeSequence
    {
    public:
      EscapeSequence( const char * ansi_r, const char * fallback_r = "" )
      : _seq( ansi_r )
      , _fbck( fallback_r )
      {}
 
      const char * str() const
      {
        if ( _fbck )       // determine _seq<>_fbck on 1st use (dtor is too early as do_ttyout() is not yet ready)
        {
          if ( ! do_ttyout() )
            _seq = _fbck;
          _fbck = nullptr;
        }
        return _seq;
      }
 
    private:
      mutable const char * _seq;
      mutable const char * _fbck;
    };

    inline std::ostream & operator<<( std::ostream & str, const EscapeSequence & obj )
    { return str << obj.str(); }
 
 
    // EscapeSequence definitions in colors.cc
 
    extern const EscapeSequence clearLN;   
 
    extern const EscapeSequence cursorUP; 
    extern const EscapeSequence cursorDOWN;     
    extern const EscapeSequence cursorRIGHT;   
    extern const EscapeSequence cursorLEFT;     
 
  } // namespace tty

 
#define ZYPPER_TRACE_SGR 0
#undef ESC
#if ( ZYPPER_TRACE_SGR < 2 )
#define ESC "\033"
#else
#define ESC "@"
#endif
  template<class Tp_>
  struct ColorTraits
  { enum { customColorCtor = false }; };
 
  // enabled via ctor Color::Constant -> Color
  template <typename CCC_>
  using EnableIfCustomColorCtor = std::enable_if_t< ansi::ColorTraits<std::decay_t<CCC_>>::customColorCtor >;

  template <typename CCC_>
  using DisableIfCustomColorCtor = std::enable_if_t< !ansi::ColorTraits<std::decay_t<CCC_>>::customColorCtor >;

  class Color
  {
  public:
    enum class Attr : std::uint8_t
    { Unchanged, Normal, Bright, Reverse };

    enum class Fg : std::uint8_t
    { Unchanged, Default, Black, Red, Green, Yellow, Blue, Magenta, Cyan, White };

    enum class Bg : std::uint8_t
    { Unchanged, Default, Black, Red, Green, Yellow, Blue, Magenta, Cyan, White };

    using UidType = std::uint32_t;

    enum Constant : std::uint8_t
    {
      Black,       BrightBlack, // BrightBlack = Darkgray
      Red,   BrightRed,
      Green,       BrightGreen,
      Yellow,     BrightYellow,       // Yellow = Brown on Standard VGA
      Blue, BrightBlue,
      Magenta,   BrightMagenta,
      Cyan, BrightCyan,
      White,       BrightWhite, // White = Gray
      Default,   BrightDefault
    };
 
  public:
    Color()
    : _comp( Attr::Normal, Fg::Default, Bg::Default )
    {}
 
    Color( Attr attr_r, Fg fg_r = Fg::Unchanged, Bg bg_r = Bg::Unchanged )
    : _comp( attr_r, fg_r, bg_r )
    {}
 
    Color( Attr attr_r, Bg bg_r )
    : _comp( attr_r, Fg::Unchanged, bg_r )
    {}
 
    Color( Fg fg_r, Bg bg_r = Bg::Unchanged  )
    : _comp( Attr::Unchanged, fg_r, bg_r )
    {}
 
    Color( Bg bg_r )
    : _comp( Attr::Unchanged, Fg::Unchanged, bg_r )
    {}

    Color( Constant color_r, Bg bg_r = Bg::Default )
    : _comp( ( color_r % 2 ? Attr::Bright : Attr::Normal ), Fg::Default, bg_r )
    {
      switch ( color_r )
      {
        case Black:
        case BrightBlack:    _comp.fg = Fg::Black;     break;
        case Red:
        case BrightRed:                _comp.fg = Fg::Red; break;
        case Green:
        case BrightGreen:    _comp.fg = Fg::Green;     break;
        case Yellow:
        case BrightYellow:  _comp.fg = Fg::Yellow;   break;
        case Blue:
        case BrightBlue:      _comp.fg = Fg::Blue;       break;
        case Magenta:
        case BrightMagenta:        _comp.fg = Fg::Magenta; break;
        case Cyan:
        case BrightCyan:      _comp.fg = Fg::Cyan;       break;
        case White:
        case BrightWhite:    _comp.fg = Fg::White;     break;
        default:
        case Default:
        case BrightDefault:        break;
      }
    }

    template<class CCC_, typename = EnableIfCustomColorCtor<CCC_>>
    Color( CCC_ && color_r )
    : Color( customColorCtor( std::forward<CCC_>(color_r) ) )
    {}
 
  public:
    static Color nocolor()
    { return Color( UidType(0) ); }

    static Color fromString( const std::string &colorName );

    explicit operator bool() const
    { return uid(); }

    static const std::string & SGRReset()
    {
#if ( ZYPPER_TRACE_SGR )
      static const std::string & _reset( *(new std::string( ESC"[0m[!]" )) );        // live until program ends
#else
      static const std::string & _reset( *(new std::string( ESC"[0m" )) );   // live until program ends
#endif
      static const std::string & _noreset( *(new std::string( "" )) );          // live until program ends
      if(!do_colors()) return _noreset;
      return _reset;
    }
 
  public:
    Color & operator<=( Color rhs )
    {
      if ( rhs._comp.attr != Attr::Unchanged ) _comp.attr = rhs._comp.attr;
      if ( rhs._comp.fg != Fg::Unchanged ) _comp.fg = rhs._comp.fg;
      if ( rhs._comp.bg != Bg::Unchanged ) _comp.bg = rhs._comp.bg;
      return *this;
    }

    Color & operator<=( Color::Attr rhs )
    { if ( rhs != Attr::Unchanged ) _comp.attr = rhs; return *this; }

    Color & operator<=( Color::Fg rhs )
    { if ( rhs != Fg::Unchanged ) _comp.fg = rhs; return *this; }

    Color & operator<=( Color::Bg rhs )
    { if ( rhs != Bg::Unchanged ) _comp.bg = rhs; return *this; }

    inline Color & operator<=( Color::Constant rhs );

    Color operator<( Color rhs ) const
    { return Color(*this) <= rhs; }

    Color operator<( Color::Attr rhs ) const
    { return Color(*this) <= rhs; }

    Color operator<( Color::Fg rhs ) const
    { return Color(*this) <= rhs; }

    Color operator<( Color::Bg rhs ) const
    { return Color(*this) <= rhs; }

    inline Color operator<( Color::Constant rhs ) const;
 
  public:
    Attr attr() const
    { return _comp.attr; }
 
    Color & attr( Attr attr_r )
    { _comp.attr = attr_r; return *this; }
 
    Fg fg() const
    { return _comp.fg; }
 
    Color & fg( Fg fg_r )
    { _comp.fg = fg_r; return *this; }
 
    Bg bg() const
    { return _comp.bg; }
 
    Color & bg( Bg bg_r )
    { _comp.bg = bg_r; return *this; }

    UidType uid() const
    { return _comp.uid; }

    const std::string & str() const
    { return genSGR( *this ); }

    std::string debugstr() const
    { return genSGR( *this ).c_str()+1; }
 
  public:
  friend inline bool operator==( Color lhs, Color rhs )
  { return( lhs.uid() == rhs.uid() ); }

  friend inline bool operator!=( Color lhs, Color rhs )
  { return ! ( lhs == rhs ); }
 
  private:
    static std::string & genSGR( Color color_r )
    {
      static std::map<UidType,std::string> & _def( *(new std::map<UidType,std::string>) );      // live until program ends
 
      if ( ! ( color_r && do_colors() ) )      // nocolor, all ::Unchanged, uid 0: return empty string
      {
#if ( ZYPPER_TRACE_SGR )
        std::string & ret( _def[0] );
        if ( ret.empty() )
          ret =  "[]";
        return ret;
#else
        return _def[0];
#endif
      }
 
      std::string & ret( _def[color_r._comp.uid] );
      if ( ret.empty() )
      {
        ret += ESC"[";
        switch ( color_r._comp.attr )
        {
          case Attr::Normal:        ret += "22;27;";        break;
          case Attr::Bright:        ret += "1;";            break;
          case Attr::Reverse:      ret += "7;";            break;
          default:
          case Attr::Unchanged:  break;
        }
        switch ( color_r._comp.fg )
        {
          case Fg::Black:      ret += "30;";           break;
          case Fg::Red:          ret += "31;";           break;
          case Fg::Green:      ret += "32;";           break;
          case Fg::Yellow:    ret += "33;";           break;
          case Fg::Blue:        ret += "34;";           break;
          case Fg::Magenta:  ret += "35;";           break;
          case Fg::Cyan:        ret += "36;";           break;
          case Fg::White:      ret += "37;";           break;
          case Fg::Default:  ret += "39;";           break;
          default:
          case Fg::Unchanged:      break;
        }
        switch ( color_r._comp.bg )
        {
          case Bg::Black:      ret += "40;";           break;
          case Bg::Red:          ret += "41;";           break;
          case Bg::Green:      ret += "42;";           break;
          case Bg::Yellow:    ret += "43;";           break;
          case Bg::Blue:        ret += "44;";           break;
          case Bg::Magenta:  ret += "45;";           break;
          case Bg::Cyan:        ret += "46;";           break;
          case Bg::White:      ret += "47;";           break;
          case Bg::Default:  ret += "49;";           break;
          default:
          case Bg::Unchanged:      break;
        }
        *ret.rbegin() = 'm';    // turn trailing ';' into 'm'
#if ( ZYPPER_TRACE_SGR )
        ret += ( color_r == Color() ? "[*]" : "[@]" );
#endif
      }
      return ret;
    }
 
  private:
    Color ( UidType ) {}
 
    union Comp {
      Comp()        // nocolor, all ::Unchanged, uid 0
      : uid( 0 )
      {}
 
      Comp( Attr attr_r, Fg fg_r, Bg bg_r )
      : attr( attr_r ), fg( fg_r ), bg( bg_r ), _f( 0 )
      {}
 
      struct {
        Color::Attr  attr;       // std::uint8_t
        Color::Fg      fg;   // std::uint8_t
        Color::Bg      bg;   // std::uint8_t
        std::uint8_t    _f;   // std::uint8_t
      };
      UidType            uid; // std::uint32_t
    } _comp;
  };
 
  template<>
  struct ColorTraits<Color::Constant>
  { enum { customColorCtor = true }; };  // enabled via ctor Color::Constant -> Color
 
  // Implememtation after ColorTraits<Color::Constant> instantiation !
  Color & Color::operator<=( Color::Constant rhs ) { return this->operator<=( Color( rhs, Bg::Unchanged ) ); }
  Color Color::operator<( Color::Constant rhs ) const       { return Color(*this) <= rhs; }

  inline std::ostream & operator<<( std::ostream & str, Color obj )
  { return str << obj.str(); }

  class ColorString
  {
  public:
    ColorString()
    : _color( Color::nocolor() )
    {}

    explicit ColorString( Color color_r )
    : _color( color_r )
    {}

    explicit ColorString( const std::string & str_r )
    : _str( str_r )
    , _color( Color::nocolor() )
    {}

    explicit ColorString( std::string && str_r )
    : _str( std::move(str_r) )
    , _color( Color::nocolor() )
    {}

    ColorString( const std::string & str_r, Color color_r )
    : _str( str_r )
    , _color( color_r )
    {}

    ColorString( std::string && str_r, Color color_r )
    : _str( std::move(str_r) )
    , _color( color_r )
    {}

    ColorString( Color color_r, const std::string & str_r )
    : _str( str_r )
    , _color( color_r )
    {}

    ColorString( Color color_r, std::string && str_r )
    : _str( std::move(str_r) )
    , _color( color_r )
    {}
 
  public:
    ColorString & operator=( const std::string & str_r )
    { _str = str_r; return *this; }

    ColorString & operator=( std::string && str_r )
    { _str = std::move(str_r); return *this; }

    // Append via '<<' (not '+=' '+') because it's
    // strictly evaluated left-to-right:
    //
    //   ColorString sep( "-", Color::Cyan );
    //   ColorString ver( "version" );
    //
    //   ver << sep << "release";    // + prints "-" in cyan :)
    //
    //   ver += sep + "release";     // - prints "-release" in cyan :(
    //   ver += sep += "release";    // - prints "-release" in cyan :(
    //   (ver += sep) += "release";  // + but ugly syntax
    //
    ColorString & operator<<( const ColorString & rhs )
    { _str += rhs.str(); return *this; }

    ColorString & operator<<( const std::string & str_r )
    { _str += str_r; return *this; }
 
  public:
    ColorString & operator=( Color color_r )
    { _color = color_r; return *this; }

    ColorString & operator<=( Color color_r )
    { _color <= color_r; return *this; }

    ColorString operator()( Color color_r ) const
    { return ColorString( _str, color_r ); }
 
  public:
    Color color() const
    { return _color; }
 
  public:
    bool empty() const
    { return plainstr().empty(); }

    std::string::size_type size() const
    { return plainstr().size(); }

    std::string str() const
    { return str( _color ); }

    std::string asString() const
    { return str(); }

    std::string str( Color color_r ) const
    {
      std::string ret( plainstr() );
      if ( do_colors() && color_r )
      {
        using zypp::str::replaceAll;
        replaceAll( ret, Color::SGRReset(), color_r.str() );
        ret = color_r.str() + ret + Color::SGRReset();
      }
#if ( ZYPPER_TRACE_SGR )
      return "[\"<]" + ret + "[>\"]";
#endif
      return ret;
    }
 
  public:
    const std::string & plainstr() const
    { return _str; }

    std::string & plainstr()
    { return _str; }

    const std::string & operator*() const
    { return plainstr(); }

    std::string & operator*()
    { return plainstr(); }
 
  private:
    std::string _str;
    Color _color;
  };

  inline std::ostream & operator<<( std::ostream & str, const ColorString & obj )
  { return str << obj.str(); }

  class ColorStream
  {
    struct nullDeleter { void operator() (void const *) const {}; };
 
  public:
    ColorStream()
    {}

    explicit ColorStream( Color color_r )
    : _color( color_r )
    {}

    explicit ColorStream( std::ostream & direct_r  )
    : ColorStream( direct_r, Color::Default )
    {}

    ColorStream( std::ostream & direct_r, Color color_r  )
    : _directP( &direct_r )
    , _color( color_r )
    { (*_directP) << _color; }

    ColorStream( const ColorStream & ) = delete;
    ColorStream & operator=( const ColorStream & ) = delete;

    ColorStream( ColorStream && ) = default;
    ColorStream & operator=( ColorStream && ) = default;
 
    ~ColorStream()
    { if ( _directP ) (*_directP) << Color::SGRReset(); }

    explicit operator std::ostream &()
    { return stream(); }
 
  public:
    ColorStream & operator=( Color color_r )
    {
      _color = color_r;
      if ( hasStream() )
        stream() << _color;
      return *this;
    }

    ColorStream & operator<=( Color color_r )
    {
      _color <= color_r;
      if ( hasStream() )
        stream() << _color;
      return *this;
    }
 
  public:
    Color color() const
    { return _color; }
 
  public:
    std::string str() const
    {
      std::string ret;
      if ( hasContent() )
      {
        ret = _bufferP->str();
        ret += Color::SGRReset();
      }
      return ret;
    }
 
  public:
    ColorStream & operator<<( Color color_r )
    { return operator<=( color_r ); }

    ColorStream & operator<<( const ColorString & val_r )
    { stream() << ( val_r.color() ? val_r.str() : val_r.str(_color) ) << _color; return *this; }

    ColorStream & operator<<( const ColorStream & val_r )
#if ( ZYPPER_TRACE_SGR )
    { if ( val_r.hasContent() ) stream() << "[<<]" << val_r.content() << _color << "[>>]"; return *this; }
#else
    { if ( val_r.hasContent() ) stream() << val_r.content() << _color; return *this; }
#endif

    template<class Tp_, typename = DisableIfCustomColorCtor<Tp_>>
    ColorStream & operator<<( const Tp_ & val_r )  // ! Universal reference here would be too greedy
    { stream() << val_r; return *this; }

    ColorStream & operator<<( std::ostream & (*omanip)( std:: ostream & ) )
    { stream() << omanip; return *this; }
 
  public:
    friend inline std::ostream & operator<<( std::ostream & str, const ColorStream & obj )
#if ( ZYPPER_TRACE_SGR )
    { if ( obj.hasContent() ) str << "[<<]" << obj.content() << Color::SGRReset() << "[>>]"; return str; }
#else
    { if ( obj.hasContent() ) str << obj.content() << Color::SGRReset(); return str; }
#endif
 
  private:
    bool hasStream() const
    { return _directP || _bufferP; }

    std::ostream & stream() const
    {
      if ( _directP )
        return *_directP;
 
      if ( !_bufferP )
      {
        _bufferP.reset( new std::ostringstream );
        *_bufferP << _color;
      }
      return *_bufferP;
    }

    bool hasContent() const
    { return !!_bufferP; }

    std::string content() const
    {
      std::string ret;
      if ( hasContent() )
        ret = _bufferP->str();
      return ret;
    }
 
  private:
    std::unique_ptr<std::ostream,nullDeleter> _directP;
    mutable std::unique_ptr<std::ostringstream> _bufferP;
    Color _color;
  };

 
#undef ZYPPER_TRACE_SGR
} // namespace ansi

 
// Drag them into this namespace:
using ansi::ColorString;
using ansi::ColorStream;

template<class Tp_>
inline ansi::ColorStream operator<<( ansi::Color color_r, Tp_ && val_r )
{ return std::move( ansi::ColorStream( color_r ) << std::forward<Tp_>(val_r) ); }
inline ansi::ColorStream operator<<( ansi::Color color_r, std::ostream & (*omanip)( std::ostream & ) )
{ return std::move( ansi::ColorStream( color_r ) << omanip ); }

template<class CCC_, class Tp_, typename = ansi::EnableIfCustomColorCtor<CCC_> >
inline ansi::ColorStream operator<<( CCC_ && color_r, Tp_ && val_r )
{ return std::move( ansi::ColorStream( std::forward<CCC_>(color_r) ) << std::forward<Tp_>(val_r) ); }
template<class CCC_, typename = ansi::EnableIfCustomColorCtor<CCC_> >
inline ansi::ColorStream operator<<( CCC_ && color_r, std::ostream & (*omanip)( std:: ostream & ) )
{ return std::move( ansi::ColorStream( std::forward<CCC_>(color_r) ) << omanip ); }
 
}
 
 
namespace std
{
template<class CCC_, typename = ztui::ansi::EnableIfCustomColorCtor<CCC_>>
inline ostream & operator<<( ostream & str, CCC_ && color_r )
{ return str << ztui::ansi::Color( forward<CCC_>(color_r) ); }
} // namespace std
 
#endif // ZYPP_TUI_UTILS_ANSI_H