Out.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 OUT_H_
#define OUT_H_
 
#include <string>
#include <sstream>
#include <optional>
 
#include <zypp-core/base/Xml.h>
#include <zypp-core/base/NonCopyable.h>
#include <zypp-core/base/Exception.h>
#include <zypp-core/base/String.h>
#include <zypp-core/base/Flags.h>
#include <utility>
#include <zypp-core/base/DefaultIntegral>
#include <zypp-core/base/DtorReset>
#include <zypp-core/Url.h>
#include <zypp-core/TriBool.h>
#include <zypp-core/ui/ProgressData>
#include <zypp-core/base/LogTools.h>
 
#include <zypp-tui/utils/text.h>
#include <zypp-tui/utils/colors.h>
#include <zypp-tui/utils/richtext.h>
#include <zypp-tui/Table.h>
#include <zypp-tui/output/PromptOptions>
 
namespace ztui {
 
class Application;

enum class ProgressEnd { done, attention, error };
 
namespace text
{
  ColorString tagNote();    
  ColorString tagWarning(); 
  ColorString tagError();   
  const char * qContinue(); 

  template <class Tltext, class Trtext>
  inline std::string join( const Tltext & ltext, const Trtext & rtext, const char * sep = " " )
  { std::string ret( zypp::str::asString(ltext) ); ret += sep; ret += zypp::str::asString(rtext); return ret; }

  inline bool endsOnWS( const std::string & str_r )
  {
    bool ret = false;
    if ( !str_r.empty() )
    { int l = *str_r.rbegin(); if ( ::strchr( " \n\t", l ) ) ret = true; }
    return ret;
  }
 
  inline const char * optBlankAfter( const std::string & str_r )
  { return( endsOnWS( str_r ) ? "" : " " ); }
}
 
namespace out
{
  static constexpr unsigned termwidthUnlimited = 0u;
  unsigned defaultTermwidth();  // Zypper::instance().out().termwidth()
} // namespace out
 
namespace out
{
  struct ListLayout
  {
    template <class TFormater> struct Writer;
 
    ListLayout( bool singleline_r, bool wrapline_r, bool gaped_r, unsigned indent_r )
    : _singleline( singleline_r )
    , _wrapline( wrapline_r )
    , _gaped( gaped_r )
    , _indent( indent_r )
    {}
    bool        _singleline; 
    bool        _wrapline;     
    bool        _gaped;           
    unsigned    _indent; 
  };
 
  namespace detail
  {
    template <bool singleline_, bool wrapline_, bool gaped_, unsigned indent_>
    struct ListLayoutInit : public ListLayout { ListLayoutInit() : ListLayout( singleline_, wrapline_, gaped_, indent_ ) {} };
  }
 
  using XmlListLayout = detail::ListLayoutInit<true, false, false, 0U>;
  using DefaultListLayout = detail::ListLayoutInit<true, true, false, 0U>;        
  using DefaultGapedListLayout = detail::ListLayoutInit<true, true, true, 0U>;        
  using IndentedListLayout = detail::ListLayoutInit<true, true, false, 2U>;      
  using IndentedGapedListLayout = detail::ListLayoutInit<true, true, true, 2U>;
  using CompressedListLayout = detail::ListLayoutInit<false, true, false, 2U>;        

  struct TableLayout
  {
    template <class TFormater> struct Writer;
  };
 
  using DefaultTableLayout = TableLayout;  
 
  // Either specialize per Type or define a custom Formater:

  template <class Tp>
  std::string asXmlListElement( const Tp & val_r );
  inline std::string asXmlListElement( const std::string & val_r ){ return val_r; }
  inline std::string asXmlListElement( const char * val_r )     { return val_r; }

  template <class Tp>
  std::string asListElement( const Tp & val_r );
  inline std::string asListElement( const std::string & val_r )    { return val_r; }
  inline std::string asListElement( const char * val_r )   { return val_r; }

  template <class Tp = void>
  TableHeader asTableHeader();
 
  template <>
  inline TableHeader asTableHeader<void>()
  { return TableHeader(); }

  template <class Tp>
  TableRow asTableRow( const Tp & val_r );

  struct XmlFormater
  {
    template <class Tp>
    std::string xmlListElement( const Tp & val_r ) const//< XML representation of element
    { return asXmlListElement( val_r ); }
  };

  struct ListFormater : public XmlFormater
  {
    using NormalLayout = DefaultListLayout;                //< ListLayout for NORMAL lists
 
    template <class Tp>
    std::string listElement( const Tp & val_r ) const        //< NORMAL representation of list element
    { return asListElement( val_r ); }
  };

  struct TableFormater : public XmlFormater
  {
    using NormalLayout = DefaultTableLayout;              //< NORMAL layout as Table
 
    TableHeader header() const                         //< TableHeader for TableRow representation
    { return asTableHeader<>(); }
 
    template <class Tp>                                 //< Representation as TableRow
    TableRow row( const Tp & val_r ) const
    { return asTableRow( val_r ); }
  };


  template <class TFormater>
  struct XmlFormaterAdaptor
  {
    using NormalLayout = XmlListLayout;                //< Layout as XML list
 
    template <class Tp>
    std::string listElement( const Tp & val_r ) const        //< use TFormater::asXmlListElement
    { return _formater.xmlListElement( val_r ); }
 
    XmlFormaterAdaptor( const TFormater & formater_r )
    : _formater( formater_r )
    {}
  private:
    const TFormater & _formater;
  };
 
} // namespace out

namespace out
{
  // TODO: wrap singlelines; support for attributed text;
  template <class TFormater>
  struct ListLayout::Writer
  {
    NON_COPYABLE( Writer );
 
    Writer( std::ostream & str_r, const ListLayout & layout_r, const TFormater & formater_r )
    : _str( str_r )
    , _layout( layout_r )
    , _formater( formater_r )
    , _linewidth( defaultTermwidth() )
    , _indent( _layout._indent, ' ' )
    {}
 
    ~Writer()
    { if ( !_layout._singleline && _cpos ) _str << std::endl; }
 
    template <class Tp>
    void operator<<( Tp && val_r ) const
    {
      const std::string & element( _formater.listElement( std::forward<Tp>(val_r) ) );
 
      if ( _layout._singleline )
      {
        if ( _layout._gaped )
          _str << std::endl;
        _str << _indent << element << std::endl;
      }
      else
      {
        if ( _cpos != 0 && ! fitsOnLine( 1/*' '*/ + element.size() ) )
          endLine();
 
        if ( _cpos == 0 )
        {
          if ( !_indent.empty() )
            printAndCount( _indent );
        }
        else
          printAndCount( " " );
 
        printAndCount( element );
      }
    }
 
  private:
    bool fitsOnLine( unsigned size_r ) const
    { return( !_layout._wrapline || _linewidth == out::termwidthUnlimited || _cpos + size_r <= _linewidth ); }
 
    void printAndCount( const std::string & element_r ) const
    { _cpos += element_r.size(); _str << element_r; }
 
    void endLine() const
    { _str << std::endl; _cpos = 0U; }
 
  private:
    std::ostream &      _str;
    const ListLayout &        _layout;
    const TFormater &   _formater;
    const unsigned      _linewidth;   
    const std::string   _indent;
    mutable unsigned    _cpos = 0U;
  };

  template <class TFormater>
  struct TableLayout::Writer
  {
    NON_COPYABLE( Writer );
 
    Writer( std::ostream & str_r, const TableLayout & layout_r, const TFormater & formater_r )
    : _str( str_r )
    , _layout( layout_r )
    , _formater( formater_r )
    {}
 
    ~Writer()
    {
      if ( !_t.empty() )
      {
        _t.setHeader( _formater.header() );
        _str << _t;
      }
    }
 
    template <class Tp>
    void operator<<( Tp && val_r ) const
    { _t.add( _formater.row( std::forward<Tp>(val_r) ) ); }
 
  private:
    std::ostream &      _str;
    const TableLayout &      _layout;
    const TFormater &   _formater;
    mutable Table  _t;
  };
 

  template <class TContainer, class TFormater, class TLayout = typename TFormater::NormalLayout>
  void writeContainer( std::ostream & str_r, const TContainer & container_r, const TFormater & formater_r, const TLayout & layout_r = TLayout() )
  {
    typedef typename TLayout::template Writer<TFormater> Writer;
    Writer writer( str_r, layout_r, formater_r );
    for ( auto && el : container_r )
      writer << el;
  }

  template <class TContainer, class TFormater>
  void xmlWriteContainer( std::ostream & str_r, const TContainer & container_r, const TFormater & formater_r )
  { writeContainer( str_r, container_r, out::XmlFormaterAdaptor<TFormater>(formater_r) ); }
 
} // namespace out
 
// Too simple on small terminals as esc-sequences may get truncated.
// A table like writer for attributed strings is desirable.
struct TermLine
{
  enum SplitFlag
  {
    SF_CRUSH    = 1<<0, //< truncate lhs, then rhs
    SF_SPLIT    = 1<<1, //< split line across two
    SF_EXPAND  = 1<<2  //< expand short lines iff stdout is a tty
  };
  ZYPP_DECLARE_FLAGS( SplitFlags, SplitFlag );
 
  TermLine( SplitFlags flags_r, char exp_r ) : flagsHint( flags_r ), expHint( exp_r ) {}
  TermLine( SplitFlags flags_r ) : flagsHint( flags_r ) {}
  TermLine( char exp_r ) : expHint( exp_r ) {}
  TermLine() {}
 
  SplitFlags flagsHint;                                //< flags to use if not passed to \ref get
  zypp::DefaultIntegral<char,' '> expHint;  //< expand char to use if not passed to \ref get
  zypp::DefaultIntegral<int,-1> percentHint;    //< draw progress indicator in expanded space if in [0,100]
 
  zypp::str::Str lhs;                          //< left side
  zypp::str::Str rhs;                          //< right side
 

  std::string get() const
  { return std::string(lhs) + std::string(rhs); }

  std::string get( unsigned width_r, SplitFlags flags_r, char exp_r ) const;
  std::string get( unsigned width_r, SplitFlags flags_r ) const
  { return get( width_r, flags_r, expHint ); }

  std::string get( unsigned width_r, char exp_r ) const
  { return get( width_r, flagsHint, exp_r ); }

  std::string get( unsigned width_r ) const
  { return get( width_r, flagsHint, expHint ); }
};
ZYPP_DECLARE_OPERATORS_FOR_FLAGS( TermLine::SplitFlags );

class Out : private zypp::base::NonCopyable
{
public:
  typedef enum
  {
    QUIET  = 0,            
    NORMAL = 1,           
    HIGH   = 2,             
    DEBUG  = 3             
  } Verbosity;

  enum TypeBit
  {
    TYPE_NORMAL = 0x01<<0,   
    TYPE_XML    = 0x01<<1       
  };
  ZYPP_DECLARE_FLAGS(Type,TypeBit);
 
  static constexpr Type TYPE_NONE       = Type(0x00);
  static constexpr Type TYPE_ALL        = Type(0xff);
 
  using PromptId = unsigned;
 
protected:
  Out(TypeBit type, Verbosity verbosity = NORMAL)
    : _verbosity(verbosity), _type(type)
  {}
 
public:
  virtual ~Out();
 
protected:
  struct ParentOut
  {
    ParentOut( Out & out_r ) : _out( out_r ) {}
    Out & out() { return _out; }
  private:
    Out & _out;
  };
 
public:
  struct XmlNode : protected ParentOut
  {
    using Attr = zypp::xmlout::Node::Attr;

    XmlNode( Out & out_r, const std::string & name_r, const std::initializer_list<Attr> & attrs_r = {} )
    : ParentOut( out_r )
    {
      if ( out().typeXML() && ! name_r.empty() )
      { _node.reset( new zypp::xmlout::Node( std::cout, name_r, attrs_r ) ); }
    }

    XmlNode( Out & out_r, const std::string & name_r, Attr attr_r )
    : XmlNode( out_r, name_r, { std::move(attr_r) } )
    {}

    XmlNode( XmlNode && rhs ) noexcept : ParentOut( rhs ) { _node.swap( rhs._node ); }
 
  private:
    zypp::scoped_ptr<zypp::xmlout::Node> _node;
  };


  void xmlNode( const std::string & name_r, const std::initializer_list<XmlNode::Attr> & attrs_r = {} )
  { if ( typeXML() ) { zypp::xmlout::node( std::cout, name_r, attrs_r ); } }

  void xmlNode( const std::string & name_r, XmlNode::Attr attr_r )
  { xmlNode( name_r, { std::move(attr_r) } ); }

  struct TitleNode : public XmlNode
  {
    TitleNode( XmlNode && node_r, const std::string & title_r = "" )
    : XmlNode( std::move(node_r) )
    { if ( out().typeNORMAL() && ! title_r.empty() ) std::cout << title_r << std::endl; }
  };
 
private:
  template <class TContainer, class TFormater>
  void container( const std::string & nodeName_r, const std::string & title_r,
                  const TContainer & container_r, const TFormater & formater_r )
  {
    TitleNode guard( XmlNode( *this, nodeName_r, XmlNode::Attr( "size", zypp::str::numstring( container_r.size() ) ) ),
                     zypp::str::Format( title_r ) % container_r.size() );
    switch ( type() )
    {
      case TYPE_NORMAL:
        writeContainer( std::cout, container_r, formater_r );
        break;
      case TYPE_XML:
        ztui::out::xmlWriteContainer( std::cout, container_r, formater_r );
        break;
    }
  }
 
public:
  template <class TContainer, class TFormater = out::ListFormater>
  void list( const std::string & nodeName_r, const std::string & title_r,
             const TContainer & container_r, const TFormater & formater_r = TFormater() )
  { container( nodeName_r, title_r, container_r, formater_r ); }

  template <class TContainer, class TFormater = out::TableFormater>
  void table( const std::string & nodeName_r, const std::string & title_r,
              const TContainer & container_r, const TFormater & formater_r = TFormater() )
  { container( nodeName_r, title_r, container_r, formater_r ); }
 
public:
  void gap() { if ( type() == TYPE_NORMAL ) std::cout << std::endl; }
 
  void printRichText( std::string text, unsigned indent_r = 0U )
  { ztui::printRichText( std::cout, std::move(text), indent_r, termwidth() ); }
 

  struct ParFormat     // placeholder until we need it
  {};

  template <class Text>
  void par( size_t indent_r, const Text & text_r, ParFormat format_r = ParFormat() )
  {
    gap();   // if needed make it optional via ParFormat
    zypp::str::Str formated;
    mbs_write_wrapped( formated.stream(), zypp::str::asString(text_r), indent_r, defaultFormatWidth( 100 ) );
    info( formated );
  }

  template <class Text>
  void par( const Text & text_r, ParFormat format_r = ParFormat() )
  { par( 0, text_r, format_r ); }
 

  template <class TText, class Text>
  void taggedPar( size_t indent_r, const TText & tag_r, const Text & text_r, ParFormat format_r = ParFormat() )
  { par( indent_r, text::join( tag_r, text_r ), format_r ); }

  template <class TText, class Text>
  void taggedPar( const TText & tag_r, const Text & text_r, ParFormat format_r = ParFormat() )
  { taggedPar( 0, tag_r, text_r, format_r ); }
 

  template <class Text>
  void notePar( size_t indent_r, const Text & text_r, ParFormat format_r = ParFormat() )
  { taggedPar( indent_r, text::tagNote(), text_r, format_r ); }

  template <class Text>
  void notePar( const Text & text_r, ParFormat format_r = ParFormat() )
  { notePar( 0, text_r, format_r ); }

  template <class Text>
  void warningPar( size_t indent_r, const Text & text_r, ParFormat format_r = ParFormat() )
  { taggedPar( indent_r, text::tagWarning(), text_r, format_r ); }

  template <class Text>
  void warningPar( const Text & text_r, ParFormat format_r = ParFormat() )
  { warningPar( 0, text_r, format_r ); }

  template <class Text>
  void errorPar( size_t indent_r, const Text & text_r, ParFormat format_r = ParFormat() )
  { taggedPar( indent_r, text::tagError(), text_r, format_r ); }

  template <class Text>
  void errorPar( const Text & text_r, ParFormat format_r = ParFormat() )
  { errorPar( 0, text_r, format_r ); }
 
public:
  virtual void info(const std::string & msg, Verbosity verbosity = NORMAL, Type mask = TYPE_ALL) = 0;
  void info( std::string msg, const std::string & msg2, Verbosity verbosity = NORMAL, Type mask = TYPE_ALL )
  { info( (msg+=msg2), verbosity, mask ); }

  virtual void infoLine(const TermLine & msg_r, Verbosity verbosity_r = NORMAL, Type mask_r = TYPE_ALL)
  { info( msg_r.get(), verbosity_r, mask_r ); }
 
  struct Info : protected ParentOut
  {
    NON_COPYABLE( Info );
 
    Info( Out & out_r )
      : ParentOut( out_r )
      , _str( new std::ostringstream )
    {}
 
    Info( Out::Info && rhs ) noexcept
      : ParentOut( rhs )
      , _str( std::move(rhs._str) )
    {}
 
    ~Info()
    { out().info( _str->str() ); }
 
    template<class Tp>
    std::ostream & operator<<( const Tp & val )
    { return (*_str) << val; /*return *this;*/ }
 
    operator std::ostream &()
    { return *_str; }
 
    std::ostream & stream()
    { return *_str; }
 
   private:
      std::unique_ptr<std::ostringstream> _str; // work around missing move ctor
  };
 
  Info info() { return Info( *this ); }
 

  void infoLR( const std::string & lmsg, const std::string & rmsg, Verbosity verbosity = NORMAL, Type mask = TYPE_ALL )
  {
    TermLine outstr( TermLine::SF_SPLIT | TermLine::SF_EXPAND );
    outstr.lhs << lmsg;
    outstr.rhs << ' ' << rmsg;
    infoLine( outstr, verbosity, mask );
  }

  void infoLRHint( const std::string & lmsg, const std::string & hint, Verbosity verbosity = NORMAL, Type mask = TYPE_ALL )
  {
    TermLine outstr( TermLine::SF_SPLIT | TermLine::SF_EXPAND );
    outstr.lhs << lmsg;
    outstr.rhs << " (" << hint << ')';
    infoLine( outstr, verbosity, mask );
  }
 

  virtual void warning(const std::string & msg, Verbosity verbosity = NORMAL, Type mask = TYPE_ALL) = 0;

  struct Error;

  virtual void error(const std::string & problem_desc, const std::string & hint = "") = 0;

  virtual void error(const zypp::Exception & e,
                     const std::string & problem_desc,
                     const std::string & hint = "") = 0;



  class ProgressBar;

  virtual void progressStart(const std::string & id,
                             const std::string & label,
                             bool is_tick = false) = 0;

  virtual void progress(const std::string & id,
                        const std::string & label,
                        int value = -1) = 0;

  virtual void progressEnd(const std::string & id,
                           const std::string & label,
                           const std::string & donetag,
                           bool error = false) = 0;
  void progressEnd( const std::string & id, const std::string & label, ProgressEnd donetag );
  void progressEnd( const std::string & id, const std::string & label, bool error = false )
  { progressEnd( id, label, error ? ProgressEnd::error : ProgressEnd::done ); }



  virtual void dwnldProgressStart(const zypp::Url & uri) = 0;

  virtual void dwnldProgress(const zypp::Url & uri,
                             int value = -1,
                             long rate = -1) = 0;
  virtual void dwnldProgressEnd(const zypp::Url & uri,
                                long rate = -1,
                                zypp::TriBool error = false) = 0;

  virtual void searchResult( const Table & table_r );

  virtual void prompt(PromptId id,
                      const std::string & prompt,
                      const PromptOptions & poptions,
                      const std::string & startdesc = "") = 0;

  virtual void promptHelp(const PromptOptions & poptions) = 0;
 
public:
  Verbosity verbosity() const { return _verbosity; }

  void setVerbosity(Verbosity verbosity) { _verbosity = verbosity; }

#define SCOPED_VERBOSITY( OUT, LEVEL ) const auto & raii __attribute__ ((__unused__))( (OUT).scopedVerbosity( LEVEL ))

  zypp::DtorReset scopedVerbosity( Verbosity verbosity_r )
  {
    std::swap( _verbosity, verbosity_r );
    return zypp::DtorReset( _verbosity, verbosity_r );
  }

  virtual void setUseColors( bool yesno ) {}
 
public:
  TypeBit type() const { return _type; }

  bool type( TypeBit type_r ) const { return type() == type_r; }
  bool typeNORMAL() const { return type( TYPE_NORMAL ); }
  bool typeXML() const { return type( TYPE_XML ); }

  unsigned defaultFormatWidth( unsigned desired_r = 0 ) const
  {
    unsigned ret = termwidth();
    if ( ret == out::termwidthUnlimited )
      ret = desired_r ? desired_r : 150U;
    else if ( desired_r < ret )
      ret = desired_r;
    return ret;
  }

  virtual unsigned termwidth() const { return out::termwidthUnlimited; }
 
protected:

  virtual bool mine(Type type) = 0;

  virtual bool progressFilter();

  virtual std::string zyppExceptionReport(const zypp::Exception & e);
 
private:
  Verbosity _verbosity;
  const TypeBit _type;
};
 
ZYPP_DECLARE_OPERATORS_FOR_FLAGS(Out::Type);

class Out::ProgressBar : private zypp::base::NonCopyable
{
public:
  struct NoStartBar {};
  static constexpr NoStartBar noStartBar = NoStartBar();
 
public:
  ProgressBar( Out & out_r, NoStartBar, std::string  progressId_r, const std::string & label_r, unsigned current_r = 0, unsigned total_r = 0 )
    : _out( out_r )
    , _progressId(std::move( progressId_r ))
  {
    if ( total_r )
      _labelPrefix = zypp::str::form( "(%*u/%u) ", numDigits( total_r ), current_r, total_r );
    else if ( current_r )
      _labelPrefix = zypp::str::form( "(%u) ", current_r );
    _progress.name( label_r );
    _progress.sendTo( Print( *this ) );
  }
 
  ProgressBar( Out & out_r,NoStartBar,  const std::string & label_r, unsigned current_r = 0, unsigned total_r = 0 )
  : ProgressBar( out_r, noStartBar, "", label_r, current_r, total_r )
  {}

  ProgressBar( Out & out_r, const std::string & progressId_r, const std::string & label_r, unsigned current_r = 0, unsigned total_r = 0 )
  : ProgressBar( out_r, noStartBar, progressId_r, label_r, current_r, total_r )
  {
    // print the initial progress bar
    _out.progressStart( _progressId, outLabel( _progress.name() ) );
  }
 
  ProgressBar( Out & out_r, const std::string & label_r, unsigned current_r = 0, unsigned total_r = 0 )
  : ProgressBar( out_r, "", label_r, current_r, total_r )
  {}

  ~ProgressBar()
  {
    _progress.noSend();        // suppress ~ProgressData final report
    if ( not _donetag )
      error( _progress.reportValue() != 100 && _progress.reportPercent() );
    _out.progressEnd( _progressId, outLabel( _progress.name() ), *_donetag );
  }

  void print()
  { _out.progress( _progressId, outLabel( _progress.name() ), _progress.reportValue() ); }

  void print( const std::string & label_r )
  { _progress.name( label_r ); print(); }

  void error( ProgressEnd donetag_r = ProgressEnd::error )
  { _donetag = donetag_r; }

  void error( bool error_r )
  { _donetag = error_r ? ProgressEnd::error : ProgressEnd::done; }

  void errorreset()
  { _donetag.reset(); }

  void error( const std::string & label_r )
  { _progress.name( label_r ); error( true ); }

  void error( const char * label_r )
  { _progress.name( label_r ); error( true ); }
 
public:
  zypp::ProgressData * operator->()
  { return &_progress; }
 
  const zypp::ProgressData * operator->() const
  { return &_progress; }
 
  zypp::ProgressData & operator*()
  { return _progress; }
 
  const zypp::ProgressData & operator*() const
  { return _progress; }

 
private:
  struct Print
  {
    Print( ProgressBar & bar_r ) : _bar( &bar_r ) {}
    bool operator()( const zypp::ProgressData & progress_r )
    { _bar->_out.progress( _bar->_progressId, _bar->outLabel( progress_r.name() ), progress_r.reportValue() ); return true; }
  private:
    ProgressBar * _bar;
  };
 
  std::string outLabel( const std::string & msg_r ) const
  { return _labelPrefix.empty() ? msg_r : _labelPrefix + msg_r; }
 
  int numDigits( unsigned num_r ) const
  { int ret = 1; while ( num_r /= 10 ) ++ret; return ret; }
 
private:
  Out & _out;
  std::optional<ProgressEnd> _donetag;
  zypp::ProgressData _progress;
  std::string _progressId;
  std::string _labelPrefix;
};


struct Out::Error
{
  Error( int exitcode_r )
  : _exitcode( exitcode_r ) {}
 
  // basic: code msg hint
  Error( int exitcode_r, std::string msg_r, std::string hint_r = std::string() )
  : _exitcode( exitcode_r ), _msg( std::move(msg_r) ), _hint( std::move(hint_r) ) {}
 
  // code exception hint
  Error( int exitcode_r, const zypp::Exception & ex_r, std::string hint_r = std::string() )
  : _exitcode( exitcode_r ), _msg( combine( ex_r ) ), _hint( std::move(hint_r) ) {}
 
  // code (msg exception) hint
  Error( int exitcode_r, std::string msg_r, const zypp::Exception & ex_r, std::string hint_r = std::string() )
  : _exitcode( exitcode_r ), _msg( combine( std::move(msg_r), ex_r ) ), _hint( std::move(hint_r) ) {}

  int report( Application & app_r ) const;
 
  int _exitcode;       //< ZYPPER_EXIT_OK indicates exitcode is already set.
  std::string _msg;
  std::string _hint;
 
private:
  static std::string combine( std::string && msg_r, const zypp::Exception & ex_r );
  static std::string combine( const zypp::Exception & ex_r );
};
 
}
 
#endif /*OUT_H_*/